]> 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
Coverity warning 22314
[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
15b84e14 61// Updated: 20 Mar 2012 Mario Sitta Reimplemented with simpler shapes
62// Updated: 20 Jul 2012 Mario Sitta Reimplemented with Composite Shape
06acb2eb 63// Updated: 12 Oct 2012 Mario Sitta Composite Shape also for EndCap
a275e8ba 64//
65// Technical data are taken from: ALICE-Thermal Screen "Cone transition"
66// (thermal-screen1_a3.ps), "Cylinder" (thermal-screen2_a3.ps), "Half
67// assembly" (thermal-screen3_a3.ps), "Flange" (thermal-screen4_a3.ps)
68
69
70 // Dimensions of the Central shield
0801d201 71 const Double_t kHalfLengthCentral = 399.9*fgkmm;
a275e8ba 72 const Double_t kThicknessCentral = 0.4*fgkmm;
73 const Double_t kInnerRadiusCentral = 8.1475*fgkcm;
74 const Double_t kOuterRadiusCentral = 9.9255*fgkcm;
75 const Double_t kInnerACentral = 3.1674*fgkcm;
76 const Double_t kInnerBCentral = 2.023 *fgkcm;
77 const Double_t kOuterACentral = 2.4374*fgkcm;
78 const Double_t kOuterBCentral = 3.8162*fgkcm;
15b84e14 79 const Double_t kCoolManifHoleWid = 24.0*fgkmm; // TO BE CHECKED!
c33a0330 80 const Double_t kCoolManifHoleLen = 57.5*fgkmm; // 54.2 + 1.5*2 + 0.3 toll.
81 const Double_t kCoolManifHoleZPos = 36.47*fgkcm;// MUST match SPD class
97f79b63 82 const Double_t kCoolSuppHoleWid = 15.0*fgkmm;
83 const Double_t kCoolSuppHoleLen = 38.4*fgkmm; // 35.1 + 1.5*2 + 0.3 toll.// TO BE CHECKED!
15b84e14 84 const Double_t kCoolSuppHoleZPos = 26.5*fgkcm;
a275e8ba 85 // Dimensions of the EndCap shield
86 const Double_t kHalfLengthEndCap = 25.*fgkmm;
87 const Double_t kThicknessEndCap = 2.0*fgkmm;
88 const Double_t kInnerRadiusEndCap = 8.0775*fgkcm;
89 const Double_t kOuterRadiusEndCap = 9.9955*fgkcm;
90 const Double_t kInnerAEndCap = 3.1453*fgkcm;
91 const Double_t kInnerBEndCap = 2.0009*fgkcm;
92 const Double_t kOuterAEndCap = 2.4596*fgkcm;
93 const Double_t kOuterBEndCap = 3.8384*fgkcm;
94 // Dimensions of the Cone shield
95 const Double_t kHalfLengthCone = 145.*fgkmm;
96 const Double_t kThicknessCone = 0.3*fgkmm;
97 const Double_t kInnerRadialCone = 37.3*fgkcm;
98 const Double_t kOuterRadialCone = 39.0*fgkcm;
99 const Double_t kInnerACone = 14.2344*fgkcm;
c573c6ec 100 const Double_t kInnerBCone = 9.0915*fgkcm;
a275e8ba 101 const Double_t kOuterACone = 9.5058*fgkcm;
c573c6ec 102 const Double_t kOuterBCone = 14.8831*fgkcm;
06acb2eb 103 // Dimensions of the filler blocks and bars
104 const Double_t kFillerBlockLength = 20.0*fgkmm;
105 const Double_t kFillerBlockHoleR = 2.4*fgkmm;
106 const Double_t kFillerBlockZTrans = 1.5*fgkmm;
107 const Double_t kFillerBarLength = 220.0*fgkmm;
108 const Double_t kFillerBarThick = 1.0*fgkmm;
a275e8ba 109 // Dimensions of the Flange's Ring and Wing
110 const Double_t kHalfLengthRing = 7.5*fgkmm;
111 const Double_t kThicknessRing = 0.3*fgkmm;
112 const Double_t kInnerRadiusRing = 37.3*fgkcm;
113 const Double_t kOuterRadiusRing = 42.0*fgkcm;
114 const Double_t kOuterRadiusWing = 49.25*fgkcm;
ca86fdb4 115 const Double_t kWideWing = 6.0*fgkcm;
0b9c8a10 116 const Double_t kThetaWing = 45.0;
a275e8ba 117 // Common data
15b84e14 118 const Double_t kThetaDeg = 36.0;
119 const Double_t kTheta = kThetaDeg*TMath::DegToRad();
a275e8ba 120 const Double_t kThicknessOmega = 0.3*fgkmm;
121
122 // Local variables
06acb2eb 123 Double_t xpos, ypos, zpos;
15b84e14 124 Double_t xXtru[24], yXtru[24];
125 Double_t xshld[24], yshld[24]; // Coord. of external thermal shape
c573c6ec 126 Double_t xair[24] , yair[24]; // Coord. of whole air shape
a275e8ba 127 Double_t xomega[48], yomega[48];
06acb2eb 128
a275e8ba 129
130 // The entire shield is made up of two half central shields
131 // symmetric with respect to the XZ plane, four half end cap
132 // shields, again symmetric with respect to the XZ plane, and four
133 // half cones, symmetric with respect to the XZ plane too.
134
135 TGeoVolumeAssembly *vM = new TGeoVolumeAssembly("ITSspdThermalShield");
136
15b84e14 137 // The central half shield: a Composite Shape of carbon fiber.
138 // We need Composite Shapes because we have holes in which the SPD
139 // cooling manifolds and their supports will be placed.
140 // All Composite elements are XTru shapes
a275e8ba 141
15b84e14 142 // First determine the external shape points
a275e8ba 143 CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
144 kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
145 kTheta,xshld,yshld);
146
a275e8ba 147 // Now rescale to get the air volume dimensions
148 InsidePoint(xshld[23], yshld[23],
149 xshld[ 0], yshld[ 0],
150 xshld[ 1], yshld[ 1], kThicknessCentral,
151 xair[0], yair[0]);
152 for (Int_t i=1; i<23; i++) {
153 InsidePoint(xshld[i-1], yshld[i-1],
154 xshld[ i ], yshld[ i ],
155 xshld[i+1], yshld[i+1], kThicknessCentral,
156 xair[i], yair[i]);
157 }
158 InsidePoint(xshld[22], yshld[22],
159 xshld[23], yshld[23],
160 xshld[ 0], yshld[ 0], kThicknessCentral,
161 xair[23], yair[23]);
162
c573c6ec 163 // Then use them to determine the Omega shape points
164 CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
a275e8ba 165
15b84e14 166 // Finally create the single Xtru volumes
167 TGeoXtru *uppershape = new TGeoXtru(2);
168 uppershape->SetName("upTS");
c573c6ec 169
15b84e14 170 for (Int_t j=0; j<6; j++) {
171 xXtru[j ] = xair[11-j];
172 yXtru[j ] = yair[11-j];
173 xXtru[j+6] = xshld[j+6];
174 yXtru[j+6] = yshld[j+6];
175 }
176 yXtru[5] = yXtru[6]; // Air is not at same Y as thermal shield
177 for (Int_t j=0; j<12; j++) {
178 xXtru[23-j] = -xXtru[j];
179 yXtru[23-j] = yXtru[j];
180 }
c573c6ec 181
15b84e14 182 uppershape->DefinePolygon(24,xXtru,yXtru);
183 uppershape->DefineSection(0,-kHalfLengthCentral);
184 uppershape->DefineSection(1, kHalfLengthCentral);
c573c6ec 185
15b84e14 186 TGeoXtru *lowershape = new TGeoXtru(2);
187 lowershape->SetName("lwTS");
c573c6ec 188
15b84e14 189 for (Int_t j=0; j<6; j++) {
190 xXtru[j ] = xshld[j];
191 yXtru[j ] = yshld[j];
192 xXtru[j+6] = xair[5-j];
193 yXtru[j+6] = yair[5-j];
194 }
195 yXtru[6] = yXtru[5]; // Air is not at same Y as thermal shield
196 for (Int_t j=0; j<12; j++) {
197 xXtru[23-j] = -xXtru[j];
198 yXtru[23-j] = yXtru[j];
199 }
a275e8ba 200
15b84e14 201 lowershape->DefinePolygon(24,xXtru,yXtru);
202 lowershape->DefineSection(0,-kHalfLengthCentral);
203 lowershape->DefineSection(1, kHalfLengthCentral);
204
205 yomega[10] = yshld[6]; // Add also base thickness
206 yomega[11] = yomega[10];
207 yomega[36] = yshld[17];
208 yomega[37] = yomega[36];
209
210 TGeoXtru *omegashape = new TGeoXtru(2);
211 omegashape->SetName("omTS");
212
213 omegashape->DefinePolygon(48,xomega,yomega);
214 omegashape->DefineSection(0,-kHalfLengthCentral);
215 omegashape->DefineSection(1, kHalfLengthCentral);
216
217 // And now the holes and their position matrices
218 Double_t radius = 0.5*(uppershape->GetY(11)+lowershape->GetY(0));
219
220 TGeoBBox *manifhole = new TGeoBBox(kCoolManifHoleWid/2,
221 0.55*(uppershape->GetY(11)-lowershape->GetY(0)),
222 kCoolManifHoleLen/2);
223 manifhole->SetName("mhTS");
224
c33a0330 225 zpos = kCoolManifHoleZPos;
15b84e14 226
227 TGeoTranslation *m1p = new TGeoTranslation("m1p",0,radius, zpos);
228 TGeoTranslation *m1n = new TGeoTranslation("m1n",0,radius,-zpos);
229 m1p->RegisterYourself();
230 m1n->RegisterYourself();
231
232 TGeoCombiTrans *m2p = new TGeoCombiTrans("m2p",radius*SinD(kThetaDeg),
233 radius*CosD(kThetaDeg),
234 zpos,
235 new TGeoRotation("",-kThetaDeg,0,0));
236 TGeoCombiTrans *m2n = new TGeoCombiTrans("m2n",radius*SinD(kThetaDeg),
237 radius*CosD(kThetaDeg),
238 -zpos,
239 new TGeoRotation("",-kThetaDeg,0,0));
240 m2p->RegisterYourself();
241 m2n->RegisterYourself();
242
243 TGeoCombiTrans *m3p = new TGeoCombiTrans("m3p",radius*SinD(-kThetaDeg),
244 radius*CosD(-kThetaDeg),
245 zpos,
246 new TGeoRotation("",kThetaDeg,0,0));
247 TGeoCombiTrans *m3n = new TGeoCombiTrans("m3n",radius*SinD(-kThetaDeg),
248 radius*CosD(-kThetaDeg),
249 -zpos,
250 new TGeoRotation("",kThetaDeg,0,0));
251 m3p->RegisterYourself();
252 m3n->RegisterYourself();
253
254 TGeoCombiTrans *m4p = new TGeoCombiTrans("m4p",radius*SinD(2*kThetaDeg),
255 radius*CosD(2*kThetaDeg),
256 zpos,
257 new TGeoRotation("",-2*kThetaDeg,0,0));
258 TGeoCombiTrans *m4n = new TGeoCombiTrans("m4n",radius*SinD(2*kThetaDeg),
259 radius*CosD(2*kThetaDeg),
260 -zpos,
261 new TGeoRotation("",-2*kThetaDeg,0,0));
262 m4p->RegisterYourself();
263 m4n->RegisterYourself();
264
265 TGeoCombiTrans *m5p = new TGeoCombiTrans("m5p",radius*SinD(-2*kThetaDeg),
266 radius*CosD(-2*kThetaDeg),
267 zpos,
268 new TGeoRotation("",2*kThetaDeg,0,0));
269 TGeoCombiTrans *m5n = new TGeoCombiTrans("m5n",radius*SinD(-2*kThetaDeg),
270 radius*CosD(-2*kThetaDeg),
271 -zpos,
272 new TGeoRotation("",2*kThetaDeg,0,0));
273 m5p->RegisterYourself();
274 m5n->RegisterYourself();
275
276 TGeoBBox *supphole = new TGeoBBox(kCoolSuppHoleWid/2,
277 0.55*(uppershape->GetY(11)-lowershape->GetY(0)),
278 kCoolSuppHoleLen/2);
279 supphole->SetName("shTS");
280
97f79b63 281 zpos = kCoolSuppHoleZPos;
15b84e14 282
283 TGeoTranslation *s1p = new TGeoTranslation("s1p",0,radius, zpos);
284 TGeoTranslation *s1n = new TGeoTranslation("s1n",0,radius,-zpos);
285 s1p->RegisterYourself();
286 s1n->RegisterYourself();
287
288 TGeoCombiTrans *s2p = new TGeoCombiTrans("s2p",radius*SinD(kThetaDeg),
289 radius*CosD(kThetaDeg),
290 zpos,
291 new TGeoRotation("",-kThetaDeg,0,0));
292 TGeoCombiTrans *s2n = new TGeoCombiTrans("s2n",radius*SinD(kThetaDeg),
293 radius*CosD(kThetaDeg),
294 -zpos,
295 new TGeoRotation("",-kThetaDeg,0,0));
296 s2p->RegisterYourself();
297 s2n->RegisterYourself();
298
299 TGeoCombiTrans *s3p = new TGeoCombiTrans("s3p",radius*SinD(-kThetaDeg),
300 radius*CosD(-kThetaDeg),
301 zpos,
302 new TGeoRotation("",kThetaDeg,0,0));
303 TGeoCombiTrans *s3n = new TGeoCombiTrans("s3n",radius*SinD(-kThetaDeg),
304 radius*CosD(-kThetaDeg),
305 -zpos,
306 new TGeoRotation("",kThetaDeg,0,0));
307 s3p->RegisterYourself();
308 s3n->RegisterYourself();
309
310 TGeoCombiTrans *s4p = new TGeoCombiTrans("s4p",radius*SinD(2*kThetaDeg),
311 radius*CosD(2*kThetaDeg),
312 zpos,
313 new TGeoRotation("",-2*kThetaDeg,0,0));
314 TGeoCombiTrans *s4n = new TGeoCombiTrans("s4n",radius*SinD(2*kThetaDeg),
315 radius*CosD(2*kThetaDeg),
316 -zpos,
317 new TGeoRotation("",-2*kThetaDeg,0,0));
318 s4p->RegisterYourself();
319 s4n->RegisterYourself();
320
321 TGeoCombiTrans *s5p = new TGeoCombiTrans("s5p",radius*SinD(-2*kThetaDeg),
322 radius*CosD(-2*kThetaDeg),
323 zpos,
324 new TGeoRotation("",2*kThetaDeg,0,0));
325 TGeoCombiTrans *s5n = new TGeoCombiTrans("s5n",radius*SinD(-2*kThetaDeg),
326 radius*CosD(-2*kThetaDeg),
327 -zpos,
328 new TGeoRotation("",2*kThetaDeg,0,0));
329 s5p->RegisterYourself();
330 s5n->RegisterYourself();
331
332 // Finally the actual shape
333 TGeoCompositeShape *centralshape = new TGeoCompositeShape("centralTS",
334 "upTS+lwTS+omTS-mhTS:m1p-mhTS:m1n-mhTS:m2p-mhTS:m2n-mhTS:m3p-mhTS:m3n-mhTS:m4p-mhTS:m4n-mhTS:m5p-mhTS:m5n-shTS:s1p-shTS:s1n-shTS:s2p-shTS:s2n-shTS:s3p-shTS:s3n-shTS:s4p-shTS:s4n-shTS:s5p-shTS:s5n");
a275e8ba 335
06acb2eb 336 // The end cap half shield: a Composite Shape of carbon fiber.
337 // We need Composite Shapes because we have elements partially
338 // entering the empty spaces, and this would create overlaps or
339 // extrusions.
340 // All Composite elements are XTru shapes
a275e8ba 341
06acb2eb 342 // First determine the external shape points
a275e8ba 343 CreateSPDThermalShape(kInnerAEndCap,kInnerBEndCap,kInnerRadiusEndCap,
344 kOuterAEndCap,kOuterBEndCap,kOuterRadiusEndCap,
345 kTheta,xshld,yshld);
346
a275e8ba 347 // Now rescale to get the air volume dimensions
348 InsidePoint(xshld[23], yshld[23],
349 xshld[ 0], yshld[ 0],
350 xshld[ 1], yshld[ 1], kThicknessEndCap,
351 xair[0], yair[0]);
352 for (Int_t i=1; i<23; i++) {
353 InsidePoint(xshld[i-1], yshld[i-1],
354 xshld[ i ], yshld[ i ],
355 xshld[i+1], yshld[i+1], kThicknessEndCap,
356 xair[i], yair[i]);
357 }
358 InsidePoint(xshld[22], yshld[22],
359 xshld[23], yshld[23],
360 xshld[ 0], yshld[ 0], kThicknessEndCap,
361 xair[23], yair[23]);
362
c573c6ec 363 // Then use them to determine the Omega shape points
3d2705b6 364 CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
c573c6ec 365
06acb2eb 366 // Finally create the single Xtru volumes
367 TGeoXtru *upendcapshape = new TGeoXtru(2);
368 upendcapshape->SetName("upEC");
369
370 for (Int_t j=0; j<6; j++) {
371 xXtru[j ] = xair[11-j];
372 yXtru[j ] = yair[11-j];
373 xXtru[j+6] = xshld[j+6];
374 yXtru[j+6] = yshld[j+6];
375 }
376 yXtru[5] = yXtru[6]; // Air is not at same Y as thermal shield
377 for (Int_t j=0; j<12; j++) {
378 xXtru[23-j] = -xXtru[j];
379 yXtru[23-j] = yXtru[j];
380 }
381
382 upendcapshape->DefinePolygon(24,xXtru,yXtru);
383 upendcapshape->DefineSection(0,-kHalfLengthEndCap);
384 upendcapshape->DefineSection(1, kHalfLengthEndCap);
385
386 TGeoXtru *lowendcapshape = new TGeoXtru(2);
387 lowendcapshape->SetName("lwEC");
388
389 for (Int_t j=0; j<6; j++) {
390 xXtru[j ] = xshld[j];
391 yXtru[j ] = yshld[j];
392 xXtru[j+6] = xair[5-j];
393 yXtru[j+6] = yair[5-j];
394 }
395 yXtru[6] = yXtru[5]; // Air is not at same Y as thermal shield
396 for (Int_t j=0; j<12; j++) {
397 xXtru[23-j] = -xXtru[j];
398 yXtru[23-j] = yXtru[j];
399 }
400
401 lowendcapshape->DefinePolygon(24,xXtru,yXtru);
402 lowendcapshape->DefineSection(0,-kHalfLengthEndCap);
403 lowendcapshape->DefineSection(1, kHalfLengthEndCap);
404
405 yomega[10] = yshld[6]; // Add also base thickness
406 yomega[11] = yomega[10];
407 yomega[36] = yshld[17];
408 yomega[37] = yomega[36];
409
410 TGeoXtru *omgendcapshape = new TGeoXtru(2);
411 omgendcapshape->SetName("omEC");
412
413 omgendcapshape->DefinePolygon(48,xomega,yomega);
414 omgendcapshape->DefineSection(0,-kHalfLengthEndCap);
415 omgendcapshape->DefineSection(1, kHalfLengthEndCap);
416
417 // Finally the actual shape
418 TGeoCompositeShape *endcapshape = new TGeoCompositeShape("endcapTS",
419 "upEC+lwEC+omEC");
420
421 // The filler block: a Xtru
422 TGeoXtru *fillershape = new TGeoXtru(2);
423
424 xXtru[0] = omgendcapshape->GetX(1) + 0.0002; // Avoid thiny extrusion
425 yXtru[0] = omgendcapshape->GetY(1);
426 xXtru[1] = omgendcapshape->GetX(0) + 0.0002;
427 yXtru[1] = omgendcapshape->GetY(0);
428 xXtru[2] = omgendcapshape->GetX(47) - 0.0002;
429 yXtru[2] = omgendcapshape->GetY(47);
430 xXtru[3] = omgendcapshape->GetX(46);
431 yXtru[3] = omgendcapshape->GetY(46);
432
433 fillershape->DefinePolygon(4,xXtru,yXtru);
434 fillershape->DefineSection(0,-kFillerBlockLength/2);
435 fillershape->DefineSection(1, kFillerBlockLength/2);
436
437 // The hole in the filler: a Tube (made of air)
438 TGeoTube *fillerholeshape = new TGeoTube(0, kFillerBlockHoleR,
439 kFillerBlockLength/2);
440
441 // The filler bar: a BBox
442 Double_t fside = omgendcapshape->GetY(14) - omgendcapshape->GetY(13);
443 TGeoBBox *fillbarshape = new TGeoBBox(fside/2, fside/2, kFillerBarLength/2);
444
445 // The hole in the bar filler: a smaller BBox (made of air)
446 fside -= 2*kFillerBarThick;
447 TGeoBBox *fillbarholeshape = new TGeoBBox(fside/2, fside/2,
448 kFillerBarLength/2);
a275e8ba 449
450 // The cone half shield is more complex since there is no basic
6f88a698 451 // TGeo shape to describe it correctly. So it is a Composite Shape
452 // of a series of TGeoArb8 shapes, in which TGeoArb8 shapes filled
453 // with air are placed, which all together make up the cone AND
454 // its internal insert. Part of the following code is adapted from
455 // old SPDThermalSheald method.
a275e8ba 456
c573c6ec 457 // sCn : Filled portions, sChn : Air holes
458 TGeoArb8 *sC1 = new TGeoArb8(kHalfLengthCone);
459 TGeoArb8 *sC2 = new TGeoArb8(kHalfLengthCone);
460 TGeoArb8 *sC3 = new TGeoArb8(kHalfLengthCone);
461 TGeoArb8 *sC4 = new TGeoArb8(kHalfLengthCone);
462 TGeoArb8 *sC5 = new TGeoArb8(kHalfLengthCone);
463 TGeoArb8 *sC6 = new TGeoArb8(kHalfLengthCone);
464 TGeoArb8 *sC7 = new TGeoArb8(kHalfLengthCone);
465 TGeoArb8 *sC8 = new TGeoArb8(kHalfLengthCone);
466 TGeoArb8 *sC9 = new TGeoArb8(kHalfLengthCone);
467 TGeoArb8 *sC10 = new TGeoArb8(kHalfLengthCone);
468 TGeoArb8 *sC11 = new TGeoArb8(kHalfLengthCone);
469
470 sC1->SetName("sC1");
471 sC2->SetName("sC2");
472 sC3->SetName("sC3");
473 sC4->SetName("sC4");
474 sC5->SetName("sC5");
475 sC6->SetName("sC6");
476 sC7->SetName("sC7");
477 sC8->SetName("sC8");
478 sC9->SetName("sC9");
479 sC10->SetName("sC10");
480 sC11->SetName("sC11");
481
482 TGeoArb8 *sCh1 = new TGeoArb8(kHalfLengthCone);
483 TGeoArb8 *sCh2 = new TGeoArb8(kHalfLengthCone);
484 TGeoArb8 *sCh3 = new TGeoArb8(kHalfLengthCone);
485 TGeoArb8 *sCh4 = new TGeoArb8(kHalfLengthCone);
486 TGeoArb8 *sCh5 = new TGeoArb8(kHalfLengthCone);
487 TGeoArb8 *sCh6 = new TGeoArb8(kHalfLengthCone);
488 TGeoArb8 *sCh7 = new TGeoArb8(kHalfLengthCone);
489 TGeoArb8 *sCh8 = new TGeoArb8(kHalfLengthCone);
490 TGeoArb8 *sCh9 = new TGeoArb8(kHalfLengthCone);
491 TGeoArb8 *sCh10 = new TGeoArb8(kHalfLengthCone);
492 TGeoArb8 *sCh11 = new TGeoArb8(kHalfLengthCone);
493
494 sCh1->SetName("sCh1");
495 sCh2->SetName("sCh2");
496 sCh3->SetName("sCh3");
497 sCh4->SetName("sCh4");
498 sCh5->SetName("sCh5");
499 sCh6->SetName("sCh6");
500 sCh7->SetName("sCh7");
501 sCh8->SetName("sCh8");
502 sCh9->SetName("sCh9");
503 sCh10->SetName("sCh10");
504 sCh11->SetName("sCh11");
505
506 // Smaller end: determine the coordinates of the points of carbon fiber
a275e8ba 507 CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
508 kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
509 kTheta,xshld,yshld);
510
c573c6ec 511 sC1->SetVertex(0, xshld[12], yshld[12]);
512 sC1->SetVertex(1, xshld[11], yshld[11]);
513 sC1->SetVertex(2, xshld[ 0], yshld[ 0]);
514 sC1->SetVertex(3, xshld[23], yshld[23]);
515
516 sC2->SetVertex(0, xshld[11], yshld[11]);
517 sC2->SetVertex(1, xshld[10], yshld[10]);
518 sC2->SetVertex(2, xshld[ 1], yshld[ 1]);
519 sC2->SetVertex(3, xshld[ 0], yshld[ 0]);
520
521 sC3->SetVertex(0, xshld[10], yshld[10]);
522 sC3->SetVertex(1, xshld[ 9], yshld[ 9]);
523 sC3->SetVertex(2, xshld[ 2], yshld[ 2]);
524 sC3->SetVertex(3, xshld[ 1], yshld[ 1]);
525
526 sC4->SetVertex(0, xshld[ 9], yshld[ 9]);
527 sC4->SetVertex(1, xshld[ 8], yshld[ 8]);
528 sC4->SetVertex(2, xshld[ 3], yshld[ 3]);
529 sC4->SetVertex(3, xshld[ 2], yshld[ 2]);
530
531 sC5->SetVertex(0, xshld[ 8], yshld[ 8]);
532 sC5->SetVertex(1, xshld[ 7], yshld[ 7]);
533 sC5->SetVertex(2, xshld[ 4], yshld[ 4]);
534 sC5->SetVertex(3, xshld[ 3], yshld[ 3]);
535
536 sC6->SetVertex(0, xshld[ 7], yshld[ 7]);
537 sC6->SetVertex(1, xshld[ 6], yshld[ 6]);
538 sC6->SetVertex(2, xshld[ 5], yshld[ 5]);
539 sC6->SetVertex(3, xshld[ 4], yshld[ 4]);
540
541 sC7->SetVertex(0,-xshld[10], yshld[10]);
542 sC7->SetVertex(1,-xshld[11], yshld[11]);
543 sC7->SetVertex(2,-xshld[ 0], yshld[ 0]);
544 sC7->SetVertex(3,-xshld[ 1], yshld[ 1]);
545
546 sC8->SetVertex(0,-xshld[ 9], yshld[ 9]);
547 sC8->SetVertex(1,-xshld[10], yshld[10]);
548 sC8->SetVertex(2,-xshld[ 1], yshld[ 1]);
549 sC8->SetVertex(3,-xshld[ 2], yshld[ 2]);
550
551 sC9->SetVertex(0,-xshld[ 8], yshld[ 8]);
552 sC9->SetVertex(1,-xshld[ 9], yshld[ 9]);
553 sC9->SetVertex(2,-xshld[ 2], yshld[ 2]);
554 sC9->SetVertex(3,-xshld[ 3], yshld[ 3]);
555
556 sC10->SetVertex(0,-xshld[ 7], yshld[ 7]);
557 sC10->SetVertex(1,-xshld[ 8], yshld[ 8]);
558 sC10->SetVertex(2,-xshld[ 3], yshld[ 3]);
559 sC10->SetVertex(3,-xshld[ 4], yshld[ 4]);
560
561 sC11->SetVertex(0,-xshld[ 6], yshld[ 6]);
562 sC11->SetVertex(1,-xshld[ 7], yshld[ 7]);
563 sC11->SetVertex(2,-xshld[ 4], yshld[ 4]);
564 sC11->SetVertex(3,-xshld[ 5], yshld[ 5]);
565
566 // Then rescale to get the air volume dimensions
567 InsidePoint(xshld[23], yshld[23],
568 xshld[ 0], yshld[ 0],
569 xshld[ 1], yshld[ 1], kThicknessCone,
570 xair[0], yair[0]);
571 for (Int_t i=1; i<23; i++) {
572 InsidePoint(xshld[i-1], yshld[i-1],
573 xshld[ i ], yshld[ i ],
574 xshld[i+1], yshld[i+1], kThicknessCone,
575 xair[i], yair[i]);
576 }
577 InsidePoint(xshld[22], yshld[22],
578 xshld[23], yshld[23],
579 xshld[ 0], yshld[ 0], kThicknessCone,
580 xair[23], yair[23]);
581
582 // Then use them to determine the Omega shape points
583 CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
a275e8ba 584
c573c6ec 585 // Finally fill the small end coordinates of the air shapes
586 sCh1->SetVertex(0, xomega[ 0], yomega[ 0]);
587 sCh1->SetVertex(1, xomega[ 1], yomega[ 1]);
588 sCh1->SetVertex(2,-xomega[ 1], yomega[ 1]);
589 sCh1->SetVertex(3,-xomega[ 0], yomega[ 0]);
590
591 sCh2->SetVertex(0, xomega[20], yomega[20]);
592 sCh2->SetVertex(1, xomega[21], yomega[21]);
593 sCh2->SetVertex(2, xomega[22], yomega[22]);
594 sCh2->SetVertex(3, xomega[23], yomega[23]);
595
596 sCh3->SetVertex(0, xomega[ 2], yomega[ 2]);
597 sCh3->SetVertex(1, xomega[ 3], yomega[ 3]);
598 sCh3->SetVertex(2, xomega[ 4], yomega[ 4]);
599 sCh3->SetVertex(3, xomega[ 5], yomega[ 5]);
600
601 sCh4->SetVertex(0, xomega[16], yomega[16]);
602 sCh4->SetVertex(1, xomega[17], yomega[17]);
603 sCh4->SetVertex(2, xomega[18], yomega[18]);
604 sCh4->SetVertex(3, xomega[19], yomega[19]);
605
606 sCh5->SetVertex(0, xomega[ 6], yomega[ 6]);
607 sCh5->SetVertex(1, xomega[ 7], yomega[ 7]);
608 sCh5->SetVertex(2, xomega[ 8], yomega[ 8]);
609 sCh5->SetVertex(3, xomega[ 9], yomega[ 9]);
610
611 sCh6->SetVertex(0, xomega[12], yomega[12]);
612 sCh6->SetVertex(1, xomega[13], yomega[13]);
613 sCh6->SetVertex(2, xomega[14], yomega[14]);
614 sCh6->SetVertex(3, xomega[15], yomega[15]);
615
616 sCh7->SetVertex(0,-xomega[21], yomega[21]);
617 sCh7->SetVertex(1,-xomega[20], yomega[20]);
618 sCh7->SetVertex(2,-xomega[23], yomega[23]);
619 sCh7->SetVertex(3,-xomega[22], yomega[22]);
620
621 sCh8->SetVertex(0,-xomega[ 3], yomega[ 3]);
622 sCh8->SetVertex(1,-xomega[ 2], yomega[ 2]);
623 sCh8->SetVertex(2,-xomega[ 5], yomega[ 5]);
624 sCh8->SetVertex(3,-xomega[ 4], yomega[ 4]);
625
626 sCh9->SetVertex(0,-xomega[17], yomega[17]);
627 sCh9->SetVertex(1,-xomega[16], yomega[16]);
628 sCh9->SetVertex(2,-xomega[19], yomega[19]);
629 sCh9->SetVertex(3,-xomega[18], yomega[18]);
630
631 sCh10->SetVertex(0,-xomega[ 7], yomega[ 7]);
632 sCh10->SetVertex(1,-xomega[ 6], yomega[ 6]);
633 sCh10->SetVertex(2,-xomega[ 9], yomega[ 9]);
634 sCh10->SetVertex(3,-xomega[ 8], yomega[ 8]);
635
636 sCh11->SetVertex(0,-xomega[13], yomega[13]);
637 sCh11->SetVertex(1,-xomega[12], yomega[12]);
638 sCh11->SetVertex(2,-xomega[15], yomega[15]);
639 sCh11->SetVertex(3,-xomega[14], yomega[14]);
640
641 // Bigger end: determine the coordinates of the points of carbon fiber
a275e8ba 642
643 // Drawings give only the radius, convert it to the apothegm
644 Double_t kInnerRadiusCone = TMath::Sqrt(kInnerRadialCone*kInnerRadialCone
645 - 0.25*kInnerACone*kInnerACone);
646 Double_t kOuterRadiusCone = TMath::Sqrt(kOuterRadialCone*kOuterRadialCone
647 - 0.25*kOuterACone*kOuterACone);
648
c573c6ec 649 CreateSPDThermalShape(kInnerACone,kInnerBCone,kInnerRadiusCone,
650 kOuterACone,kOuterBCone,kOuterRadiusCone,
651 kTheta,xshld,yshld);
a275e8ba 652
c573c6ec 653 sC1->SetVertex(4, xshld[12], yshld[12]);
654 sC1->SetVertex(5, xshld[11], yshld[11]);
655 sC1->SetVertex(6, xshld[ 0], yshld[ 0]);
656 sC1->SetVertex(7, xshld[23], yshld[23]);
657
658 sC2->SetVertex(4, xshld[11], yshld[11]);
659 sC2->SetVertex(5, xshld[10], yshld[10]);
660 sC2->SetVertex(6, xshld[ 1], yshld[ 1]);
661 sC2->SetVertex(7, xshld[ 0], yshld[ 0]);
662
663 sC3->SetVertex(4, xshld[10], yshld[10]);
664 sC3->SetVertex(5, xshld[ 9], yshld[ 9]);
665 sC3->SetVertex(6, xshld[ 2], yshld[ 2]);
666 sC3->SetVertex(7, xshld[ 1], yshld[ 1]);
667
668 sC4->SetVertex(4, xshld[ 9], yshld[ 9]);
669 sC4->SetVertex(5, xshld[ 8], yshld[ 8]);
670 sC4->SetVertex(6, xshld[ 3], yshld[ 3]);
671 sC4->SetVertex(7, xshld[ 2], yshld[ 2]);
672
673 sC5->SetVertex(4, xshld[ 8], yshld[ 8]);
674 sC5->SetVertex(5, xshld[ 7], yshld[ 7]);
675 sC5->SetVertex(6, xshld[ 4], yshld[ 4]);
676 sC5->SetVertex(7, xshld[ 3], yshld[ 3]);
677
678 sC6->SetVertex(4, xshld[ 7], yshld[ 7]);
679 sC6->SetVertex(5, xshld[ 6], yshld[ 6]);
680 sC6->SetVertex(6, xshld[ 5], yshld[ 5]);
681 sC6->SetVertex(7, xshld[ 4], yshld[ 4]);
682
683 sC7->SetVertex(4,-xshld[10], yshld[10]);
684 sC7->SetVertex(5,-xshld[11], yshld[11]);
685 sC7->SetVertex(6,-xshld[ 0], yshld[ 0]);
686 sC7->SetVertex(7,-xshld[ 1], yshld[ 1]);
687
688 sC8->SetVertex(4,-xshld[ 9], yshld[ 9]);
689 sC8->SetVertex(5,-xshld[10], yshld[10]);
690 sC8->SetVertex(6,-xshld[ 1], yshld[ 1]);
691 sC8->SetVertex(7,-xshld[ 2], yshld[ 2]);
692
693 sC9->SetVertex(4,-xshld[ 8], yshld[ 8]);
694 sC9->SetVertex(5,-xshld[ 9], yshld[ 9]);
695 sC9->SetVertex(6,-xshld[ 2], yshld[ 2]);
696 sC9->SetVertex(7,-xshld[ 3], yshld[ 3]);
697
698 sC10->SetVertex(4,-xshld[ 7], yshld[ 7]);
699 sC10->SetVertex(5,-xshld[ 8], yshld[ 8]);
700 sC10->SetVertex(6,-xshld[ 3], yshld[ 3]);
701 sC10->SetVertex(7,-xshld[ 4], yshld[ 4]);
702
703 sC11->SetVertex(4,-xshld[ 6], yshld[ 6]);
704 sC11->SetVertex(5,-xshld[ 7], yshld[ 7]);
705 sC11->SetVertex(6,-xshld[ 4], yshld[ 4]);
706 sC11->SetVertex(7,-xshld[ 5], yshld[ 5]);
707
708 // Then rescale to get the air volume dimensions
709 InsidePoint(xshld[23], yshld[23],
710 xshld[ 0], yshld[ 0],
711 xshld[ 1], yshld[ 1], kThicknessCone,
712 xair[0], yair[0]);
713 for (Int_t i=1; i<23; i++) {
714 InsidePoint(xshld[i-1], yshld[i-1],
715 xshld[ i ], yshld[ i ],
716 xshld[i+1], yshld[i+1], kThicknessCone,
717 xair[i], yair[i]);
718 }
719 InsidePoint(xshld[22], yshld[22],
720 xshld[23], yshld[23],
721 xshld[ 0], yshld[ 0], kThicknessCone,
722 xair[23], yair[23]);
a275e8ba 723
c573c6ec 724 // Then use them to determine the Omega shape points
725 CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
a275e8ba 726
c573c6ec 727 // Finally fill the big end coordinates of the air shapes
728 sCh1->SetVertex(4, xomega[ 0], yomega[ 0]);
729 sCh1->SetVertex(5, xomega[ 1], yomega[ 1]);
730 sCh1->SetVertex(6,-xomega[ 1], yomega[ 1]);
731 sCh1->SetVertex(7,-xomega[ 0], yomega[ 0]);
732
733 sCh2->SetVertex(4, xomega[20], yomega[20]);
734 sCh2->SetVertex(5, xomega[21], yomega[21]);
735 sCh2->SetVertex(6, xomega[22], yomega[22]);
736 sCh2->SetVertex(7, xomega[23], yomega[23]);
737
738 sCh3->SetVertex(4, xomega[ 2], yomega[ 2]);
739 sCh3->SetVertex(5, xomega[ 3], yomega[ 3]);
740 sCh3->SetVertex(6, xomega[ 4], yomega[ 4]);
741 sCh3->SetVertex(7, xomega[ 5], yomega[ 5]);
742
743 sCh4->SetVertex(4, xomega[16], yomega[16]);
744 sCh4->SetVertex(5, xomega[17], yomega[17]);
745 sCh4->SetVertex(6, xomega[18], yomega[18]);
746 sCh4->SetVertex(7, xomega[19], yomega[19]);
747
748 sCh5->SetVertex(4, xomega[ 6], yomega[ 6]);
749 sCh5->SetVertex(5, xomega[ 7], yomega[ 7]);
750 sCh5->SetVertex(6, xomega[ 8], yomega[ 8]);
751 sCh5->SetVertex(7, xomega[ 9], yomega[ 9]);
752
753 sCh6->SetVertex(4, xomega[12], yomega[12]);
754 sCh6->SetVertex(5, xomega[13], yomega[13]);
755 sCh6->SetVertex(6, xomega[14], yomega[14]);
756 sCh6->SetVertex(7, xomega[15], yomega[15]);
757
758 sCh7->SetVertex(4,-xomega[21], yomega[21]);
759 sCh7->SetVertex(5,-xomega[20], yomega[20]);
760 sCh7->SetVertex(6,-xomega[23], yomega[23]);
761 sCh7->SetVertex(7,-xomega[22], yomega[22]);
762
763 sCh8->SetVertex(4,-xomega[ 3], yomega[ 3]);
764 sCh8->SetVertex(5,-xomega[ 2], yomega[ 2]);
765 sCh8->SetVertex(6,-xomega[ 5], yomega[ 5]);
766 sCh8->SetVertex(7,-xomega[ 4], yomega[ 4]);
767
768 sCh9->SetVertex(4,-xomega[17], yomega[17]);
769 sCh9->SetVertex(5,-xomega[16], yomega[16]);
770 sCh9->SetVertex(6,-xomega[19], yomega[19]);
771 sCh9->SetVertex(7,-xomega[18], yomega[18]);
772
773 sCh10->SetVertex(4,-xomega[ 7], yomega[ 7]);
774 sCh10->SetVertex(5,-xomega[ 6], yomega[ 6]);
775 sCh10->SetVertex(6,-xomega[ 9], yomega[ 9]);
776 sCh10->SetVertex(7,-xomega[ 8], yomega[ 8]);
777
778 sCh11->SetVertex(4,-xomega[13], yomega[13]);
779 sCh11->SetVertex(5,-xomega[12], yomega[12]);
780 sCh11->SetVertex(6,-xomega[15], yomega[15]);
781 sCh11->SetVertex(7,-xomega[14], yomega[14]);
782
6f88a698 783 // Now the actual carbon fiber cone: a CompositeShape
784 TGeoCompositeShape *sCone = new TGeoCompositeShape("sCone",
785 "sC1+sC2+sC3+sC4+sC5+sC6+sC7+sC8+sC9+sC10+sC11");
786
a275e8ba 787 // Finally the carbon fiber Ring with its Wings and their
788 // stesalite inserts. They are Tube and TubeSeg shapes
789
790 TGeoTube *ringshape = new TGeoTube(kInnerRadiusRing,kOuterRadiusRing,
791 kHalfLengthRing);
792
793 TGeoTube *ringinsertshape = new TGeoTube(kInnerRadiusRing+kThicknessRing,
794 kOuterRadiusRing-kThicknessRing,
795 kHalfLengthRing-kThicknessRing);
796
797 Double_t angleWideWing, angleWideWingThickness;
798 angleWideWing = (kWideWing/kOuterRadiusWing)*TMath::RadToDeg();
799 angleWideWingThickness = (kThicknessRing/kOuterRadiusWing)*TMath::RadToDeg();
800
801 TGeoTubeSeg *wingshape = new TGeoTubeSeg(kOuterRadiusRing,kOuterRadiusWing,
802 kHalfLengthRing, 0, angleWideWing);
803
804 TGeoTubeSeg *winginsertshape = new TGeoTubeSeg(kOuterRadiusRing,
805 kOuterRadiusWing-kThicknessRing, kHalfLengthRing-kThicknessRing,
806 angleWideWingThickness, angleWideWing-angleWideWingThickness);
807
808
809 // We have the shapes: now create the real volumes
810
811 TGeoMedium *medSPDcf = mgr->GetMedium("ITS_SPD shield$");
812 TGeoMedium *medSPDair = mgr->GetMedium("ITS_SPD AIR$");
813 TGeoMedium *medSPDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
814
815 TGeoVolume *centralshield = new TGeoVolume("SPDcentralshield",
816 centralshape,medSPDcf);
817 centralshield->SetVisibility(kTRUE);
818 centralshield->SetLineColor(7);
819 centralshield->SetLineWidth(1);
c573c6ec 820 centralshield->SetFillColor(centralshield->GetLineColor());
821 centralshield->SetFillStyle(4090); // 90% transparent
822
a275e8ba 823 TGeoVolume *endcapshield = new TGeoVolume("SPDendcapshield",
824 endcapshape,medSPDcf);
825 endcapshield->SetVisibility(kTRUE);
826 endcapshield->SetLineColor(7);
827 endcapshield->SetLineWidth(1);
06acb2eb 828 endcapshield->SetFillColor(endcapshield->GetLineColor());
829 endcapshield->SetFillStyle(4090); // 90% transparent
830
831 TGeoVolume *fillerblock = new TGeoVolume("SPDfillerblock",
832 fillershape,medSPDcf);
833 fillerblock->SetVisibility(kTRUE);
834 fillerblock->SetLineColor(7);
835 fillerblock->SetLineWidth(1);
836 fillerblock->SetFillColor(fillerblock->GetLineColor());
837 fillerblock->SetFillStyle(4090); // 90% transparent
838
839 TGeoVolume *fillerhole = new TGeoVolume("SPDfillerhole",
840 fillerholeshape,medSPDair);
841 fillerhole->SetVisibility(kTRUE);
842 fillerhole->SetLineColor(5); // Yellow
843 fillerhole->SetLineWidth(1);
844 fillerhole->SetFillColor(fillerhole->GetLineColor());
845 fillerhole->SetFillStyle(4090); // 90% transparent
846
847 ypos = (fillershape->GetY(0)+fillershape->GetY(1))/2;
848 fillerblock->AddNode(fillerhole, 1, new TGeoTranslation(0, ypos, 0));
849
850 zpos = omgendcapshape->GetZ(1) - fillershape->GetZ(1) - kFillerBlockZTrans;
851 endcapshield->AddNode(fillerblock, 1, new TGeoTranslation(0, 0, zpos));
852 endcapshield->AddNode(fillerblock, 2, new TGeoCombiTrans(0, 0, zpos,
853 new TGeoRotation("", kThetaDeg,0,0)));
854 endcapshield->AddNode(fillerblock, 3, new TGeoCombiTrans(0, 0, zpos,
855 new TGeoRotation("",-kThetaDeg,0,0)));
856 endcapshield->AddNode(fillerblock, 4, new TGeoCombiTrans(0, 0, zpos,
857 new TGeoRotation("", 2*kThetaDeg,0,0)));
858 endcapshield->AddNode(fillerblock, 5, new TGeoCombiTrans(0, 0, zpos,
859 new TGeoRotation("",-2*kThetaDeg,0,0)));
860
861 TGeoVolume *fillerbar = new TGeoVolume("SPDfillerbar",
862 fillbarshape,medSPDcf);
863 fillerbar->SetVisibility(kTRUE);
864 fillerbar->SetLineColor(7);
865 fillerbar->SetLineWidth(1);
866 fillerbar->SetFillColor(fillerbar->GetLineColor());
867 fillerbar->SetFillStyle(4090); // 90% transparent
868
869 TGeoVolume *fillbarhole = new TGeoVolume("SPDfillerbarhole",
870 fillbarholeshape,medSPDair);
871 fillbarhole->SetVisibility(kTRUE);
872 fillbarhole->SetLineColor(5); // Yellow
873 fillbarhole->SetLineWidth(1);
874 fillbarhole->SetFillColor(fillbarhole->GetLineColor());
875 fillbarhole->SetFillStyle(4090); // 90% transparent
876
877 fillerbar->AddNode(fillbarhole, 1, 0);
a275e8ba 878
6f88a698 879 TGeoVolume *vCone = new TGeoVolume("SPDconeshield",sCone,medSPDcf);
880 vCone->SetVisibility(kTRUE);
881 vCone->SetLineColor(7);
882 vCone->SetLineWidth(1);
883 vCone->SetFillColor(vCone->GetLineColor());
884 vCone->SetFillStyle(4090); // 90% transparent
a275e8ba 885
886 TGeoVolume *vCh1 = new TGeoVolume("SPDconeshieldH1",sCh1,medSPDair);
a275e8ba 887 vCh1->SetVisibility(kTRUE);
888 vCh1->SetLineColor(5); // Yellow
889 vCh1->SetLineWidth(1);
890 vCh1->SetFillColor(vCh1->GetLineColor());
891 vCh1->SetFillStyle(4090); // 90% transparent
892
a275e8ba 893 TGeoVolume *vCh2 = new TGeoVolume("SPDconeshieldH2",sCh2,medSPDair);
a275e8ba 894 vCh2->SetVisibility(kTRUE);
895 vCh2->SetLineColor(5); // Yellow
896 vCh2->SetLineWidth(1);
897 vCh2->SetFillColor(vCh2->GetLineColor());
898 vCh2->SetFillStyle(4090); // 90% transparent
899
c573c6ec 900 TGeoVolume *vCh3 = new TGeoVolume("SPDconeshieldH3",sCh3,medSPDair);
901 vCh3->SetVisibility(kTRUE);
902 vCh3->SetLineColor(5); // Yellow
903 vCh3->SetLineWidth(1);
904 vCh3->SetFillColor(vCh3->GetLineColor());
905 vCh3->SetFillStyle(4090); // 90% transparent
906
c573c6ec 907 TGeoVolume *vCh4 = new TGeoVolume("SPDconeshieldH4",sCh4,medSPDair);
908 vCh4->SetVisibility(kTRUE);
909 vCh4->SetLineColor(5); // Yellow
910 vCh4->SetLineWidth(1);
911 vCh4->SetFillColor(vCh4->GetLineColor());
912 vCh4->SetFillStyle(4090); // 90% transparent
913
c573c6ec 914 TGeoVolume *vCh5 = new TGeoVolume("SPDconeshieldH5",sCh5,medSPDair);
915 vCh5->SetVisibility(kTRUE);
916 vCh5->SetLineColor(5); // Yellow
917 vCh5->SetLineWidth(1);
918 vCh5->SetFillColor(vCh5->GetLineColor());
919 vCh5->SetFillStyle(4090); // 90% transparent
920
c573c6ec 921 TGeoVolume *vCh6 = new TGeoVolume("SPDconeshieldH6",sCh6,medSPDair);
922 vCh6->SetVisibility(kTRUE);
923 vCh6->SetLineColor(5); // Yellow
924 vCh6->SetLineWidth(1);
925 vCh6->SetFillColor(vCh6->GetLineColor());
926 vCh6->SetFillStyle(4090); // 90% transparent
927
c573c6ec 928 TGeoVolume *vCh7 = new TGeoVolume("SPDconeshieldH7",sCh7,medSPDair);
929 vCh7->SetVisibility(kTRUE);
930 vCh7->SetLineColor(5); // Yellow
931 vCh7->SetLineWidth(1);
932 vCh7->SetFillColor(vCh7->GetLineColor());
933 vCh7->SetFillStyle(4090); // 90% transparent
934
c573c6ec 935 TGeoVolume *vCh8 = new TGeoVolume("SPDconeshieldH8",sCh8,medSPDair);
936 vCh8->SetVisibility(kTRUE);
937 vCh8->SetLineColor(5); // Yellow
938 vCh8->SetLineWidth(1);
939 vCh8->SetFillColor(vCh8->GetLineColor());
940 vCh8->SetFillStyle(4090); // 90% transparent
941
c573c6ec 942 TGeoVolume *vCh9 = new TGeoVolume("SPDconeshieldH9",sCh9,medSPDair);
943 vCh9->SetVisibility(kTRUE);
944 vCh9->SetLineColor(5); // Yellow
945 vCh9->SetLineWidth(1);
946 vCh9->SetFillColor(vCh9->GetLineColor());
947 vCh9->SetFillStyle(4090); // 90% transparent
948
c573c6ec 949 TGeoVolume *vCh10 = new TGeoVolume("SPDconeshieldH10",sCh10,medSPDair);
950 vCh10->SetVisibility(kTRUE);
951 vCh10->SetLineColor(5); // Yellow
952 vCh10->SetLineWidth(1);
953 vCh10->SetFillColor(vCh10->GetLineColor());
954 vCh10->SetFillStyle(4090); // 90% transparent
955
c573c6ec 956 TGeoVolume *vCh11 = new TGeoVolume("SPDconeshieldH11",sCh11,medSPDair);
957 vCh11->SetVisibility(kTRUE);
958 vCh11->SetLineColor(5); // Yellow
959 vCh11->SetLineWidth(1);
960 vCh11->SetFillColor(vCh11->GetLineColor());
961 vCh11->SetFillStyle(4090); // 90% transparent
962
6f88a698 963 vCone->AddNode(vCh1 ,1,0);
964 vCone->AddNode(vCh2 ,1,0);
965 vCone->AddNode(vCh3 ,1,0);
966 vCone->AddNode(vCh4 ,1,0);
967 vCone->AddNode(vCh5 ,1,0);
968 vCone->AddNode(vCh6 ,1,0);
969 vCone->AddNode(vCh7 ,1,0);
970 vCone->AddNode(vCh8 ,1,0);
971 vCone->AddNode(vCh9 ,1,0);
972 vCone->AddNode(vCh10,1,0);
973 vCone->AddNode(vCh11,1,0);
c573c6ec 974
a275e8ba 975 TGeoVolume *ring = new TGeoVolume("SPDshieldring",ringshape,medSPDcf);
976 ring->SetVisibility(kTRUE);
977 ring->SetLineColor(7);
978 ring->SetLineWidth(1);
979
980 TGeoVolume *ringinsert = new TGeoVolume("SPDshieldringinsert",
981 ringinsertshape,medSPDste);
982 ringinsert->SetVisibility(kTRUE);
983 ringinsert->SetLineColor(3); // Green
984// ringinsert->SetLineWidth(1);
985 ringinsert->SetFillColor(ringinsert->GetLineColor());
986 ringinsert->SetFillStyle(4010); // 10% transparent
987
988 ring->AddNode(ringinsert,1,0);
989
990 TGeoVolume *wing = new TGeoVolume("SPDshieldringwing",wingshape,medSPDcf);
991 wing->SetVisibility(kTRUE);
992 wing->SetLineColor(7);
993 wing->SetLineWidth(1);
994
6f88a698 995 TGeoVolume *winginsert = new TGeoVolume("SPDshieldwinginsert",
a275e8ba 996 winginsertshape,medSPDste);
997 winginsert->SetVisibility(kTRUE);
998 winginsert->SetLineColor(3); // Green
999// winginsert->SetLineWidth(1);
1000 winginsert->SetFillColor(winginsert->GetLineColor());
1001 winginsert->SetFillStyle(4010); // 10% transparent
1002
1003 wing->AddNode(winginsert,1,0);
1004
1005
1006 // Add all volumes in the assembly
0801d201 1007 const Double_t kLittleZTrans = 0.1*fgkmm;
1008 vM->AddNode(centralshield,1,new TGeoTranslation(0,0,-kLittleZTrans));
1009 vM->AddNode(centralshield,2,new TGeoCombiTrans( 0,0,-kLittleZTrans,
1010 new TGeoRotation("",180,0,0)));
a275e8ba 1011
0801d201 1012 zpos = kHalfLengthCentral+kHalfLengthEndCap;
a275e8ba 1013 vM->AddNode(endcapshield,1,
0801d201 1014 new TGeoTranslation(0,0, zpos-kLittleZTrans));
c6bf4fa5 1015 vM->AddNode(endcapshield,2,new TGeoCombiTrans(
1016 0, 0,-zpos-kLittleZTrans, new TGeoRotation("", 0,180,0) ) );
a275e8ba 1017 vM->AddNode(endcapshield,3,new TGeoCombiTrans(
c6bf4fa5 1018 0, 0, zpos-kLittleZTrans, new TGeoRotation("",180, 0,0) ) );
a275e8ba 1019 vM->AddNode(endcapshield,4,new TGeoCombiTrans(
c6bf4fa5 1020 0, 0,-zpos-kLittleZTrans, new TGeoRotation("",180,180,0) ) );
a275e8ba 1021
06acb2eb 1022 xpos = omgendcapshape->GetX(13) + fillbarshape->GetDX();
1023 ypos = omgendcapshape->GetY(13) + fillbarshape->GetDY();
1024 zpos -= fillbarshape->GetDZ();
1025 vM->AddNode(fillerbar, 1, new TGeoTranslation( xpos, ypos, zpos));
1026 vM->AddNode(fillerbar, 2, new TGeoTranslation(-xpos, ypos, zpos));
1027 vM->AddNode(fillerbar, 3, new TGeoTranslation( xpos,-ypos, zpos));
c6bf4fa5 1028 vM->AddNode(fillerbar, 4, new TGeoTranslation(-xpos,-ypos, zpos));
06acb2eb 1029 vM->AddNode(fillerbar, 5, new TGeoTranslation( xpos, ypos,-zpos));
1030 vM->AddNode(fillerbar, 6, new TGeoTranslation(-xpos, ypos,-zpos));
1031 vM->AddNode(fillerbar, 7, new TGeoTranslation( xpos,-ypos,-zpos));
1032 vM->AddNode(fillerbar, 8, new TGeoTranslation(-xpos,-ypos,-zpos));
1033
0801d201 1034 zpos = kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone;
6f88a698 1035 vM->AddNode(vCone ,1, new TGeoTranslation(0, 0, zpos-kLittleZTrans));
1036
1037 vM->AddNode(vCone ,2, new TGeoCombiTrans(0, 0, zpos-kLittleZTrans,
c573c6ec 1038 new TGeoRotation("", 0, 0, 180) ));
1039
6f88a698 1040 vM->AddNode(vCone ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
c573c6ec 1041 new TGeoRotation("", 0, 180, 0) ));
1042
6f88a698 1043 vM->AddNode(vCone ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
c573c6ec 1044 new TGeoRotation("", 0, 180, 180) ));
a275e8ba 1045
0801d201 1046 zpos = kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
1047 + kHalfLengthRing;
1048 vM->AddNode(ring,1,new TGeoTranslation(0, 0, zpos-kLittleZTrans));
1049 vM->AddNode(ring,2,new TGeoTranslation(0, 0,-zpos-kLittleZTrans));
a275e8ba 1050
0b9c8a10 1051 for (Int_t i=0; i<4; i++) {
1052 Double_t thetaW = kThetaWing*(2*i+1) - angleWideWing/2.;
0801d201 1053 vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0, zpos-kLittleZTrans,
1054 new TGeoRotation("",thetaW,0,0) ) );
1055 vM->AddNode(wing,2*i+2,new TGeoCombiTrans(0, 0,-zpos-kLittleZTrans,
1056 new TGeoRotation("",thetaW,0,0) ) );
a275e8ba 1057 }
1058
1059 // Some debugging if requested
1060 if(GetDebug(1)){
1061 vM->PrintNodes();
1062 vM->InspectShape();
1063 }
1064
1065 // Finally put the entire shield in the mother volume
1066 moth->AddNode(vM,1,0);
1067
1068 return;
1069}
1070
1071//______________________________________________________________________
1072void AliITSv11GeometrySupport::CreateSPDThermalShape(
1073 Double_t ina, Double_t inb, Double_t inr,
1074 Double_t oua, Double_t oub, Double_t our,
43aefea7 1075 Double_t t, Double_t *x , Double_t *y ) const
a275e8ba 1076{
1077//
1078// Creates the proper sequence of X and Y coordinates to determine
1079// the base XTru polygon for the SPD thermal shapes
1080//
1081// Input:
1082// ina, inb : inner shape sides
1083// inr : inner radius
1084// oua, oub : outer shape sides
1085// our : outer radius
1086// t : theta angle
1087//
1088// Output:
1089// x, y : coordinate vectors [24]
1090//
1091// Created: 14 Nov 2007 Mario Sitta
1092// Updated: 11 Dec 2007 Mario Sitta
1093//
1094 Double_t xlocal[6],ylocal[6];
1095
1096 //Create the first inner quadrant (X > 0)
1097 FillSPDXtruShape(ina,inb,inr,t,xlocal,ylocal);
1098 for (Int_t i=0; i<6; i++) {
1099 x[i] = xlocal[i];
1100 y[i] = ylocal[i];
1101 }
1102
1103 // Then reflex on the second quadrant (X < 0)
1104 for (Int_t i=0; i<6; i++) {
1105 x[23-i] = -x[i];
1106 y[23-i] = y[i];
1107 }
1108
1109 // Now create the first outer quadrant (X > 0)
1110 FillSPDXtruShape(oua,oub,our,t,xlocal,ylocal);
1111 for (Int_t i=0; i<6; i++) {
1112 x[11-i] = xlocal[i];
1113 y[11-i] = ylocal[i];
1114 }
1115
1116 // Finally reflex on the second quadrant (X < 0)
1117 for (Int_t i=0; i<6; i++) {
1118 x[12+i] = -x[11-i];
1119 y[12+i] = y[11-i];
1120 }
1121
1122 return;
1123}
1124
1125//______________________________________________________________________
1126void AliITSv11GeometrySupport::CreateSPDOmegaShape(
21ea473f 1127 const Double_t *xin, const Double_t *yin, Double_t d,
1128 Double_t *x, Double_t *y)
a275e8ba 1129{
1130//
1131// Creates the proper sequence of X and Y coordinates to determine
1132// the SPD Omega XTru polygon
1133//
1134// Input:
1135// xin, yin : coordinates of the air volume
1136// d : Omega shape thickness
1137// t : theta angle
1138//
1139// Output:
1140// x, y : coordinate vectors [48]
1141//
1142// Created: 17 Nov 2007 Mario Sitta
1143// Updated: 11 Dec 2007 Mario Sitta
3d2705b6 1144// Updated: 20 Feb 2009 Mario Sitta New algorithm (the old one
1145// gives erroneous vertexes)
a275e8ba 1146//
a275e8ba 1147
3d2705b6 1148 // This vector contains the index of those points which coincide
1149 // with the corresponding points in the air shape
1150 Int_t indexAir2Omega[12] = {1, 2, 5, 6, 9, 10, 11, 15, 16, 19, 20, 23};
a275e8ba 1151
3d2705b6 1152 // First fill those vertexes corresponding to
1153 // the edges aligned to the air shape edges
1154 for (Int_t j=0; j<12; j++) {
1155 x[*(indexAir2Omega+j)] = xin[j];
1156 y[*(indexAir2Omega+j)] = yin[j];
1157 }
a275e8ba 1158
3d2705b6 1159 // Now get the coordinates of the first inner point
1160 PointFromParallelLines(x[23],y[23],x[1],y[1],d,x[0],y[0]);
a275e8ba 1161
3d2705b6 1162 // Knowing this, the second internal point can be determined
1163 InsidePoint(x[0],y[0],x[1],y[1],x[2],y[2],d,x[22],y[22]);
a275e8ba 1164
3d2705b6 1165 // The third point is now computable
1166 ReflectPoint(x[1],y[1],x[2],y[2],x[22],y[22],x[21],y[21]);
a275e8ba 1167
3d2705b6 1168 // Repeat this logic
1169 InsidePoint(x[21],y[21],x[20],y[20],x[19],y[19],-d,x[3],y[3]);
a275e8ba 1170
3d2705b6 1171 ReflectPoint(x[20],y[20],x[19],y[19],x[3],y[3],x[4],y[4]);
a275e8ba 1172
3d2705b6 1173 InsidePoint(x[4],y[4],x[5],y[5],x[6],y[6],d,x[18],y[18]);
a275e8ba 1174
3d2705b6 1175 ReflectPoint(x[5],y[5],x[6],y[6],x[18],y[18],x[17],y[17]);
a275e8ba 1176
3d2705b6 1177 InsidePoint(x[17],y[17],x[16],y[16],x[15],y[15],-d,x[7],y[7]);
a275e8ba 1178
3d2705b6 1179 ReflectPoint(x[16],y[16],x[15],y[15],x[7],y[7],x[8],y[8]);
a275e8ba 1180
3d2705b6 1181 InsidePoint(x[8],y[8],x[9],y[9],x[10],y[10],d,x[14],y[14]);
a275e8ba 1182
1183 // These need to be fixed explicitly
a275e8ba 1184 x[12] = x[11];
1185 y[12] = y[11] + d;
1186 x[13] = x[10] + d;
1187 y[13] = y[12];
1188
3d2705b6 1189 // Finally reflect on the negative side
a275e8ba 1190 for (Int_t i=0; i<24; i++) {
1191 x[24+i] = -x[23-i];
1192 y[24+i] = y[23-i];
1193 }
1194
1195 // Wow ! We've finished
1196 return;
172b0d90 1197}
a275e8ba 1198
172b0d90 1199//______________________________________________________________________
a275e8ba 1200void AliITSv11GeometrySupport::FillSPDXtruShape(Double_t a, Double_t b,
1201 Double_t r, Double_t t,
21ea473f 1202 Double_t *x, Double_t *y) const
a275e8ba 1203{
1204//
1205// Creates the partial sequence of X and Y coordinates to determine
1206// the lateral part of the SPD thermal shield
1207//
1208// Input:
1209// a, b : shape sides
1210// r : radius
1211// t : theta angle
1212//
1213// Output:
1214// x, y : coordinate vectors [6]
1215//
1216// Created: 14 Nov 2007 Mario Sitta
1217//
1218 x[0] = a/2;
1219 y[0] = r;
1220
1221 x[1] = x[0] + b * TMath::Cos(t/2);
1222 y[1] = y[0] - b * TMath::Sin(t/2);
1223
1224 x[2] = x[1] + a * TMath::Cos(t);
1225 y[2] = y[1] - a * TMath::Sin(t);
1226
1227 x[3] = x[2] + b * TMath::Cos(3*t/2);
1228 y[3] = y[2] - b * TMath::Sin(3*t/2);
1229
1230 x[4] = x[3] + a * TMath::Cos(2*t);
1231 y[4] = y[3] - a * TMath::Sin(2*t);
1232
1233 x[5] = x[4];
1234 y[5] = 0.;
1235
1236 return;
172b0d90 1237}
a275e8ba 1238
3d2705b6 1239//______________________________________________________________________
1240void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1,
1241 Double_t x2, Double_t y2, Double_t d,
21ea473f 1242 Double_t &x, Double_t &y) const
3d2705b6 1243{
1244//
1245// Determines the X and Y of the first internal point of the Omega shape
1246// (i.e. the coordinates of a point given two parallel lines passing by
1247// two points and placed at a known distance)
1248//
1249// Input:
1250// x1, y1 : first point
1251// x2, y2 : second point
1252// d : distance between the two lines
1253//
1254// Output:
1255// x, y : coordinate of the point
1256//
1257// Created: 22 Feb 2009 Mario Sitta
1258//
1259//Begin_Html
1260/*
1261<img src="ITS/doc/PointFromParallelLines.gif">
1262*/
1263//End_Html
1264
1265 // The slope of the paralles lines at a distance d
1266 Double_t m;
1267
1268 // The parameters of the solving equation
1269 // a x^2 - 2 b x + c = 0
1270 Double_t a = (x1 - x2)*(x1 - x2) - d*d;
1271 Double_t b = (x1 - x2)*(y1 - y2);
1272 Double_t c = (y1 - y2)*(y1 - y2) - d*d;
1273
21ea473f 1274 // (delta4 is Delta/4 because we use the reduced formula)
1275 Double_t delta4 = b*b - a*c;
3d2705b6 1276
1277 // Compute the slope of the two parallel lines
1278 // (one of the two possible slopes, the one with the smaller
1279 // absolute value is needed)
21ea473f 1280 if (delta4 < 0) { // Should never happen with our data, but just to be sure
3d2705b6 1281 x = -1; // x is expected positive, so this flags an error
1282 return;
1283 } else
21ea473f 1284 m = (b + TMath::Sqrt(delta4))/a; // b is negative with our data
3d2705b6 1285
1286 // Finally compute the coordinates of the point
1287 x = x2 + (y1 - y2 - d)/m;
1288 y = y1 - d;
1289
1290 // Done
1291 return;
1292}
1293
1294//______________________________________________________________________
1295void AliITSv11GeometrySupport::ReflectPoint(Double_t x1, Double_t y1,
1296 Double_t x2, Double_t y2,
1297 Double_t x3, Double_t y3,
21ea473f 1298 Double_t &x, Double_t &y) const
3d2705b6 1299{
1300//
1301// Given two points (x1,y1) and (x2,y2), determines the point (x,y)
1302// lying on the line parallel to the line passing by these points,
1303// at a distance d and passing by the point (x3,y3), which is symmetric to
1304// the third point with respect to the axis of the segment delimited by
1305// the two first points.
1306//
1307// Input:
1308// x1, y1 : first point
1309// x2, y2 : second point
1310// x3, y3 : third point
1311// d : distance between the two lines
1312//
1313// Output:
1314// x, y : coordinate of the reflected point
1315//
1316// Created: 22 Feb 2009 Mario Sitta
1317//
1318//Begin_Html
1319/*
1320<img src="ITS/doc/ReflectPoint.gif">
1321*/
1322//End_Html
1323
1324 // The slope of the line passing by the first two points
1325 Double_t k = (y2 - y1)/(x2 - x1);
1326
1327 // The middle point of the segment 1-2
1328 Double_t xK = (x1 + x2)/2.;
1329 Double_t yK = (y1 + y2)/2.;
1330
1331 // The intercept between the axis of the segment 1-2 and the line
1332 // passing by 3 and parallel to the line passing by 1-2
1333 Double_t xH = (k*k*x3 + k*(yK - y3) + xK)/(k*k + 1);
1334 Double_t yH = k*(xH - x3) + y3;
1335
1336 // The point symmetric to 3 with respect to H
1337 x = 2*xH - x3;
1338 y = 2*yH - y3;
1339
1340 // Done
1341 return;
1342}
1343
172b0d90 1344//______________________________________________________________________
43aefea7 1345void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,const TGeoManager *mgr)
7d6c23de 1346{
1347//
1348// Creates the SDD support cone and cylinder geometry as a
1349// volume assembly and adds it to the mother volume
1350// (part of this code is taken or anyway inspired to SDDCone method
1351// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
1352//
1353// Input:
1354// moth : the TGeoVolume owing the volume structure
1355// mgr : the GeoManager (default gGeoManager)
1356// Output:
1357//
1358// Created: ??? Bjorn S. Nilsen
1359// Updated: 18 Feb 2008 Mario Sitta
6b99a08f 1360// Updated: 25 Jul 2008 Mario Sitta SDDCarbonFiberCone simpler
96eb8210 1361// Updated: 10 Jun 2010 Mario Sitta Cables across cone holes added
7d6c23de 1362//
1363// Technical data are taken from: "Supporto Generale Settore SDD"
1364// (technical drawings ALR-0816/1-B), "Supporto Globale Settore SDD"
1365// (technical drawings ALR-0816/2A, ALR-0816/2B, ALR-0816/2C, ALR-0816/2D),
1366// private communication with B. Giraudo
1367
1368 // Dimensions of the Central cylinder and flanges
1369 const Double_t kCylinderHalfLength = (790.0/2)*fgkmm;
1370 const Double_t kCylinderInnerR = (210.0/2)*fgkmm;
1371 const Double_t kCylinderOuterR = (231.0/2)*fgkmm;
1372 const Double_t kFlangeHalfLength = ( 15.0/2)*fgkmm;
1373 const Double_t kFlangeInnerR = (210.5/2)*fgkmm;
1374 const Double_t kFlangeOuterR = (230.5/2)*fgkmm;
1375 const Double_t kInsertoHalfLength =
1376 kCylinderHalfLength - 2*kFlangeHalfLength;
1377// const Double_t kCFThickness = kFlangeInnerR - kCylinderInnerR;
1378 const Double_t kBoltDiameter = 6.0*fgkmm; // M6 screw
1379 const Double_t kBoltDepth = 6.0*fgkmm; // In the flange
1380 const Double_t kBoltRadius = (220.0/2)*fgkmm; // Radius in flange
1381 const Double_t kThetaBolt = 30.0*fgkDegree;
1382 const Int_t kNBolts = (Int_t)(360.0/kThetaBolt);
1383 // Dimensions of the Cone
1384 const Double_t kConeROutMin = (540.0/2)*fgkmm;
1385 const Double_t kConeROutMax = (560.0/2)*fgkmm;
3a299c65 1386 const Double_t kConeRCurv = 10.0*fgkmm; // Radius of curvature
7d6c23de 1387 const Double_t kConeRinMin = (210.0/2)*fgkmm;
6b99a08f 1388// const Double_t kConeRinMax = (216.0/2)*fgkmm;
7d6c23de 1389 const Double_t kConeRinCylinder = (231.0/2)*fgkmm;
3a299c65 1390 const Double_t kConeZCylinder = 192.0*fgkmm;
7d6c23de 1391 const Double_t kConeZOuterMilled = 23.0*fgkmm;
1392 const Double_t kConeDZin = 15.0*fgkmm; // ???
3a299c65 1393 const Double_t kConeThickness = 10.0*fgkmm; // Rohacell + Carb.Fib.
7d6c23de 1394 const Double_t kConeTheta = 45.0*fgkDegree; // SDD cone angle
1395 const Double_t kSinConeTheta =
1396 TMath::Sin(kConeTheta*TMath::DegToRad());
1397 const Double_t kCosConeTheta =
1398 TMath::Cos(kConeTheta*TMath::DegToRad());
1399 const Double_t kTanConeTheta =
1400 TMath::Tan(kConeTheta*TMath::DegToRad());
1401 // Dimensions of the Cone Inserts
96eb8210 1402 const Double_t kConeCFThickness = 1.5*fgkmm;//Carbon fiber thickness
7d6c23de 1403 // Dimensions of the Cone Holes
1404 const Double_t kHole1RMin = (450.0/2)*fgkmm;
3a299c65 1405 const Double_t kHole1RMax = (530.0/2)*fgkmm;
7d6c23de 1406 const Double_t kHole2RMin = (280.0/2)*fgkmm;
1407 const Double_t kHole2RMax = (375.0/2)*fgkmm;
1408 const Double_t kHole1Phi = 25.0*fgkDegree;
1409 const Double_t kHole2Phi = 50.0*fgkDegree;
1410 const Double_t kHole3RMin = 205.0*fgkmm;
1411 const Double_t kHole3DeltaR = 15*fgkmm;
1412 const Double_t kHole3Width = 30*fgkmm;
1413 const Int_t kNHole3 = 6 ;
1414 const Double_t kHole4RMin = 116.0*fgkmm;
1415 const Double_t kHole4DeltaR = 15*fgkmm;
3a299c65 1416 const Double_t kHole4Width = 30*fgkmm;
1417 // const Int_t kNHole4 = 3 ;
96eb8210 1418 // Fraction of materials in holes
1419 const Double_t kHolePlasticFrac = 0.55846;
1420 const Double_t kHoleCuFrac = 0.06319;
1421 const Double_t kHoleGlassFrac = 0.02652;
7d6c23de 1422
1423 // Local variables
1424 Double_t x, y, z, t, dza, rmin, rmax;
1425
1426
7d6c23de 1427 // Recover the needed materials
96eb8210 1428 TGeoMedium *medSDDcf = mgr->GetMedium("ITS_SDD C (M55J)$");
1429 TGeoMedium *medSDDair = mgr->GetMedium("ITS_SDD AIR$");
1430 TGeoMedium *medSDDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
1431 TGeoMedium *medSDDroh = mgr->GetMedium("ITS_ROHACELL$");
1432 TGeoMedium *medSDDss = mgr->GetMedium("ITS_INOX$");
1433 TGeoMedium *medSDDplast = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
1434 TGeoMedium *medSDDCu = mgr->GetMedium("ITS_COPPER$");
1435 TGeoMedium *medSDDglass = mgr->GetMedium("ITS_SDD OPTICFIB$");
7d6c23de 1436
1437 // First define the geometrical shapes
1438
1439 // Central cylinder with its internal foam and the lateral flanges:
1440 // a carbon fiber Tube which contains a rohacell Tube and two
1441 // stesalite Tube's
1442 TGeoTube *cylindershape = new TGeoTube(kCylinderInnerR,kCylinderOuterR,
1443 kCylinderHalfLength);
1444
1445 TGeoTube *insertoshape = new TGeoTube(kFlangeInnerR,kFlangeOuterR,
1446 kInsertoHalfLength);
1447
1448 TGeoTube *flangeshape = new TGeoTube(kFlangeInnerR,kFlangeOuterR,
1449 kFlangeHalfLength);
1450
1451 // The flange bolt: it is a Tube
1452 TGeoTube *boltshape = new TGeoTube(0.0, 0.5*kBoltDiameter, 0.5*kBoltDepth);
1453
1454 // Debug if requested
1455 if (GetDebug(1)) {
1456 cylindershape->InspectShape();
1457 insertoshape->InspectShape();
1458 flangeshape->InspectShape();
1459 boltshape->InspectShape();
1460 }
1461
1462
1463 // We have the shapes: now create the real volumes
1464
1465 TGeoVolume *cfcylinder = new TGeoVolume("SDDCarbonFiberCylinder",
1466 cylindershape,medSDDcf);
1467 cfcylinder->SetVisibility(kTRUE);
1468 cfcylinder->SetLineColor(4); // Blue
1469 cfcylinder->SetLineWidth(1);
1470 cfcylinder->SetFillColor(cfcylinder->GetLineColor());
1471 cfcylinder->SetFillStyle(4000); // 0% transparent
1472
1473 TGeoVolume *foamcylinder = new TGeoVolume("SDDFoamCylinder",
1474 insertoshape,medSDDroh);
1475 foamcylinder->SetVisibility(kTRUE);
1476 foamcylinder->SetLineColor(3); // Green
1477 foamcylinder->SetLineWidth(1);
1478 foamcylinder->SetFillColor(foamcylinder->GetLineColor());
1479 foamcylinder->SetFillStyle(4050); // 50% transparent
1480
1481 TGeoVolume *flangecylinder = new TGeoVolume("SDDFlangeCylinder",
1482 flangeshape,medSDDste);
1483 flangecylinder->SetVisibility(kTRUE);
1484 flangecylinder->SetLineColor(2); // Red
1485 flangecylinder->SetLineWidth(1);
1486 flangecylinder->SetFillColor(flangecylinder->GetLineColor());
1487 flangecylinder->SetFillStyle(4050); // 50% transparent
1488
1489 TGeoVolume *bolt = new TGeoVolume("SDDFlangeBolt",boltshape,medSDDss);
1490 bolt->SetVisibility(kTRUE);
1491 bolt->SetLineColor(1); // Black
1492 bolt->SetLineWidth(1);
1493 bolt->SetFillColor(bolt->GetLineColor());
1494 bolt->SetFillStyle(4050); // 50% transparent
1495
1496 // Mount up the cylinder
1497 for(Int_t i=0; i<kNBolts; i++){
1498 t = kThetaBolt*i;
aa177c73 1499 x = kBoltRadius*CosD(t);
1500 y = kBoltRadius*SinD(t);
7d6c23de 1501 z = kFlangeHalfLength-kBoltDepth;
1502 flangecylinder->AddNode(bolt, i+1, new TGeoTranslation("",x,y,z));
1503 }
1504
1505 cfcylinder->AddNode(foamcylinder,1,0);
1506 cfcylinder->AddNode(flangecylinder,1,
1507 new TGeoTranslation(0, 0, kInsertoHalfLength+kFlangeHalfLength));
1508 cfcylinder->AddNode(flangecylinder,2,new TGeoCombiTrans(
1509 0, 0, -kInsertoHalfLength-kFlangeHalfLength,
1510 new TGeoRotation("",0,180,0) ) );
1511
1512
1513 // SDD Support Cone with its internal inserts: a carbon fiber Pcon
1514 // with holes which contains a stesalite Pcon which on turn contains a
1515 // rohacell Pcon
1516
1517 dza = kConeThickness/kSinConeTheta-(kConeROutMax-kConeROutMin)/kTanConeTheta;
1518
6b99a08f 1519 TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 10);
7d6c23de 1520
1521 coneshape->Z(0) = 0.0;
1522 coneshape->Rmin(0) = kConeROutMin;
1523 coneshape->Rmax(0) = kConeROutMax;
1524
1525 coneshape->Z(1) = kConeZOuterMilled - dza;
1526 coneshape->Rmin(1) = coneshape->GetRmin(0);
1527 coneshape->Rmax(1) = coneshape->GetRmax(0);
1528
1529 coneshape->Z(2) = kConeZOuterMilled;
1530 coneshape->Rmax(2) = coneshape->GetRmax(0);
1531
1532 RadiusOfCurvature(kConeRCurv,0.,coneshape->GetZ(1),
1533 coneshape->GetRmin(1),kConeTheta,z,rmin);
1534 coneshape->Z(3) = z;
1535 coneshape->Rmin(3) = rmin;
1536
1537 coneshape->Rmin(2) = RminFrom2Points(coneshape,3,1,coneshape->GetZ(2));
1538
1539 RadiusOfCurvature(kConeRCurv,0.,coneshape->GetZ(2),
1540 coneshape->GetRmax(2),kConeTheta,z,rmax);
1541 coneshape->Z(4) = z;
1542 coneshape->Rmax(4) = rmax;
1543 coneshape->Rmin(4) = RminFromZpCone(coneshape,3,kConeTheta,
1544 coneshape->GetZ(4),0.0);
1545
1546 coneshape->Rmax(3) = RmaxFrom2Points(coneshape,4,2,coneshape->GetZ(3));
1547
6b99a08f 1548 coneshape->Z(6) = kConeZCylinder - kConeDZin;
1549
1550 RadiusOfCurvature(kConeRCurv,90.0,coneshape->GetZ(6),0.0,
1551 90.0-kConeTheta,z,rmin);
1552 coneshape->Z(5) = z;
1553 coneshape->Rmin(5) = RminFromZpCone(coneshape,3,kConeTheta,z);
1554 coneshape->Rmax(5) = RmaxFromZpCone(coneshape,4,kConeTheta,z);
1555
1556 RadiusOfCurvature(kConeRCurv,90.-kConeTheta,
1557 0.0,coneshape->Rmin(5),90.0,z,rmin);
1558 coneshape->Rmin(6) = rmin;
1559 coneshape->Rmax(6) = RmaxFromZpCone(coneshape,4,kConeTheta,
1560 coneshape->GetZ(6));
1561
1562 coneshape->Z(7) = coneshape->GetZ(6);
7d6c23de 1563 coneshape->Rmin(7) = kConeRinMin;
6b99a08f 1564 coneshape->Rmax(7) = coneshape->GetRmax(6);
7d6c23de 1565
1566 coneshape->Rmin(8) = kConeRinMin;
1567
6b99a08f 1568 RadiusOfCurvature(kConeRCurv,90.0,kConeZCylinder,kConeRinCylinder,
1569 90.0-kConeTheta,z,rmax);
1570 coneshape->Z(8) = z;
7d6c23de 1571 coneshape->Rmax(8) = rmax;
7d6c23de 1572
1573 coneshape->Z(9) = kConeZCylinder;
1574 coneshape->Rmin(9) = kConeRinMin;
6b99a08f 1575 coneshape->Rmax(9) = kConeRinCylinder;
7d6c23de 1576
7d6c23de 1577
1578 // SDD Cone Insert: another Pcon
1579 Double_t x0, y0, x1, y1, x2, y2;
1580 TGeoPcon *coneinsertshape = new TGeoPcon(0.0, 360.0, 9);
1581
1582 coneinsertshape->Z(0) = coneshape->GetZ(0) + kConeCFThickness;
1583 coneinsertshape->Rmin(0) = coneshape->GetRmin(0) + kConeCFThickness;
1584 coneinsertshape->Rmax(0) = coneshape->GetRmax(0) - kConeCFThickness;
1585
1586 x0 = coneshape->GetZ(0); y0 = coneshape->GetRmin(0);
1587 x1 = coneshape->GetZ(1); y1 = coneshape->GetRmin(1);
1588 x2 = coneshape->GetZ(2); y2 = coneshape->GetRmin(2);
1589 InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin);
1590 coneinsertshape->Z(1) = z;
1591 coneinsertshape->Rmin(1) = rmin;
1592 coneinsertshape->Rmax(1) = coneinsertshape->GetRmax(0);
1593
1594 x0 = coneshape->GetZ(1); y0 = coneshape->GetRmax(1);
1595 x1 = coneshape->GetZ(2); y1 = coneshape->GetRmax(2);
1596 x2 = coneshape->GetZ(3); y2 = coneshape->GetRmax(3);
1597 InsidePoint(x0, y0, x1, y1, x2, y2, -kConeCFThickness, z, rmax);
1598 coneinsertshape->Z(2) = z;
1599 coneinsertshape->Rmax(2) = rmax;
1600
1601 x0 = coneshape->GetZ(2); y0 = coneshape->GetRmin(2);
1602 x1 = coneshape->GetZ(3); y1 = coneshape->GetRmin(3);
1603 x2 = coneshape->GetZ(4); y2 = coneshape->GetRmin(4);
1604 InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin);
1605 coneinsertshape->Z(3) = z;
1606 coneinsertshape->Rmin(3) = rmin;
1607
1608 x0 = coneinsertshape->GetZ(1); y0 = coneinsertshape->GetRmin(1);
1609 x1 = coneinsertshape->GetZ(3); y1 = coneinsertshape->GetRmin(3);
1610 coneinsertshape->Rmin(2) = Yfrom2Points(x0, y0, x1, y1,
1611 coneinsertshape->Z(2));
1612
1613 x0 = coneshape->GetZ(3); y0 = coneshape->GetRmax(3);
1614 x1 = coneshape->GetZ(4); y1 = coneshape->GetRmax(4);
1615 x2 = coneshape->GetZ(5); y2 = coneshape->GetRmax(5);
1616 InsidePoint(x0, y0, x1, y1, x2, y2, -kConeCFThickness, z, rmax);
1617 coneinsertshape->Z(4) = z;
1618 coneinsertshape->Rmax(4) = rmax;
1619
1620 x0 = coneinsertshape->GetZ(2); y0 = coneinsertshape->GetRmax(2);
1621 x1 = coneinsertshape->GetZ(4); y1 = coneinsertshape->GetRmax(4);
1622 coneinsertshape->Rmax(3) = Yfrom2Points(x0, y0, x1, y1,
1623 coneinsertshape->Z(3));
1624
1625 x0 = coneshape->GetZ(4); y0 = coneshape->GetRmin(4);
1626 x1 = coneshape->GetZ(5); y1 = coneshape->GetRmin(5);
1627 x2 = coneshape->GetZ(6); y2 = coneshape->GetRmin(6);
1628 InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin);
1629 coneinsertshape->Z(5) = z;
1630 coneinsertshape->Rmin(5) = rmin;
1631 coneinsertshape->Rmax(5) = coneinsertshape->GetRmax(4) -
1632 kTanConeTheta*(coneinsertshape->GetZ(5) - coneinsertshape->GetZ(4));
1633
1634 x0 = coneinsertshape->GetZ(3); y0 = coneinsertshape->GetRmin(3);
1635 x1 = coneinsertshape->GetZ(5); y1 = coneinsertshape->GetRmin(5);
1636 coneinsertshape->Rmin(4) = Yfrom2Points(x0, y0, x1, y1,
1637 coneinsertshape->Z(4));
1638
1639 x0 = coneshape->GetZ(5); y0 = coneshape->GetRmin(5);
1640 x1 = coneshape->GetZ(6); y1 = coneshape->GetRmin(6);
1641 x2 = coneshape->GetZ(7); y2 = coneshape->GetRmin(7);
1642 InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin);
1643 coneinsertshape->Z(6) = z;
1644 coneinsertshape->Rmin(6) = rmin;
1645 coneinsertshape->Rmax(6) = coneinsertshape->GetRmax(4) -
1646 kTanConeTheta*(coneinsertshape->GetZ(6) - coneinsertshape->GetZ(4));
1647
1648 coneinsertshape->Z(7) = coneinsertshape->GetZ(6);
1649 coneinsertshape->Rmin(7) = coneshape->GetRmin(7) + kConeCFThickness;
1650 coneinsertshape->Rmax(7) = coneinsertshape->GetRmax(6);
1651
1652 coneinsertshape->Z(8) = coneshape->GetZ(9) - kConeCFThickness;
1653 coneinsertshape->Rmin(8) = coneinsertshape->GetRmin(7);
1654 coneinsertshape->Rmax(8) = coneinsertshape->GetRmax(4) -
1655 kTanConeTheta*(coneinsertshape->GetZ(8) - coneinsertshape->GetZ(4));
1656
1657 // SDD Cone Foam: another Pcon
1658 TGeoPcon *conefoamshape = new TGeoPcon(0.0, 360.0, 4);
1659
1660 RadiusOfCurvature(kConeRCurv+kConeCFThickness,0.0,coneinsertshape->GetZ(1),
1661 coneinsertshape->GetRmin(1),kConeTheta,z,rmin);
1662
1663 conefoamshape->Z(0) = z;
1664 conefoamshape->Rmin(0) = rmin;
1665 conefoamshape->Rmax(0) = conefoamshape->GetRmin(0);
1666
1667 conefoamshape->Z(1) = conefoamshape->GetZ(0)+
1668 (kConeThickness-2.0*kConeCFThickness)/kSinConeTheta;
1669 conefoamshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1670 conefoamshape->GetZ(1));
1671 conefoamshape->Rmax(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1672 conefoamshape->GetZ(1));
1673
1674 conefoamshape->Z(2) = coneshape->GetZ(5)-kConeCFThickness;
1675 conefoamshape->Rmin(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1676 conefoamshape->GetZ(2));
1677 conefoamshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1678 conefoamshape->GetZ(2));
1679
1680 conefoamshape->Z(3) = coneinsertshape->GetZ(5)+
1681 (kConeThickness-2.0*kConeCFThickness)*kCosConeTheta;
1682 conefoamshape->Rmax(3) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1683 conefoamshape->GetZ(3));
1684 conefoamshape->Rmin(3) = conefoamshape->GetRmax(3);
1685
1686 // SDD Cone Holes: Pcon's
a30e33f0 1687 // A single hole volume gives an overlap with coneinsert, so
1688 // three contiguous volumes are created: one to be put in the cone foam
1689 // and two in the cone carbon fiber envelope
7d6c23de 1690 TGeoPcon *hole1shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1691
1692 hole1shape->Rmin(0) = kHole1RMax;
1693 hole1shape->Rmax(0) = hole1shape->GetRmin(0);
a30e33f0 1694 hole1shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta,
7d6c23de 1695 hole1shape->GetRmin(0));
1696
1697 hole1shape->Rmax(1) = hole1shape->GetRmax(0);
a30e33f0 1698 hole1shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1699 hole1shape->GetRmax(1));
a30e33f0 1700 hole1shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
7d6c23de 1701 hole1shape->GetZ(1));
1702
1703 hole1shape->Rmin(2) = kHole1RMin;
a30e33f0 1704 hole1shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
7d6c23de 1705 hole1shape->GetRmin(2));
a30e33f0 1706 hole1shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
7d6c23de 1707 hole1shape->GetZ(2));
1708
1709 hole1shape->Rmin(3) = hole1shape->GetRmin(2);
1710 hole1shape->Rmax(3) = hole1shape->GetRmin(3);
a30e33f0 1711 hole1shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1712 hole1shape->GetRmax(3));
1713
a30e33f0 1714 TGeoPcon *hole11shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1715
1716 hole11shape->Rmin(0) = kHole1RMax;
1717 hole11shape->Rmax(0) = hole11shape->GetRmin(0);
1718 hole11shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
1719 hole11shape->GetRmin(0));
1720
1721 hole11shape->Rmax(1) = hole11shape->GetRmax(0);
1722 hole11shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1723 hole11shape->GetRmax(1));
1724 hole11shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1725 hole11shape->GetZ(1));
1726
1727 hole11shape->Rmin(2) = kHole1RMin;
1728 hole11shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
1729 hole11shape->GetRmin(2));
1730 hole11shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1731 hole11shape->GetZ(2));
1732
1733 hole11shape->Rmin(3) = hole11shape->GetRmin(2);
1734 hole11shape->Rmax(3) = hole11shape->GetRmin(3);
1735 hole11shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1736 hole11shape->GetRmax(3));
1737
1738 TGeoPcon *hole12shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1739
1740 hole12shape->Rmin(0) = kHole1RMax;
1741 hole12shape->Rmax(0) = hole12shape->GetRmin(0);
1742 hole12shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1743 hole12shape->GetRmin(0));
1744
1745 hole12shape->Rmax(1) = hole12shape->GetRmax(0);
1746 hole12shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1747 hole12shape->GetRmax(1));
1748 hole12shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1749 hole12shape->GetZ(1));
1750
1751 hole12shape->Rmin(2) = kHole1RMin;
1752 hole12shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1753 hole12shape->GetRmin(2));
1754 hole12shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1755 hole12shape->GetZ(2));
1756
1757 hole12shape->Rmin(3) = hole12shape->GetRmin(2);
1758 hole12shape->Rmax(3) = hole12shape->GetRmin(3);
1759 hole12shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1760 hole12shape->GetRmax(3));
1761
1762 //
7d6c23de 1763 TGeoPcon *hole2shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1764
1765 hole2shape->Rmin(0) = kHole2RMax;
1766 hole2shape->Rmax(0) = hole2shape->GetRmin(0);
a30e33f0 1767 hole2shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta,
7d6c23de 1768 hole2shape->GetRmin(0));
1769
1770 hole2shape->Rmax(1) = hole2shape->GetRmax(0);
a30e33f0 1771 hole2shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1772 hole2shape->GetRmax(1));
a30e33f0 1773 hole2shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
7d6c23de 1774 hole2shape->GetZ(1));
1775
1776 hole2shape->Rmin(2) = kHole2RMin;
a30e33f0 1777 hole2shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
7d6c23de 1778 hole2shape->GetRmin(2));
a30e33f0 1779 hole2shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
7d6c23de 1780 hole2shape->GetZ(2));
1781
1782 hole2shape->Rmin(3) = hole2shape->GetRmin(2);
1783 hole2shape->Rmax(3) = hole2shape->GetRmin(3);
a30e33f0 1784 hole2shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1785 hole2shape->GetRmax(3));
1786
a30e33f0 1787 TGeoPcon *hole21shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1788
1789 hole21shape->Rmin(0) = kHole2RMax;
1790 hole21shape->Rmax(0) = hole21shape->GetRmin(0);
1791 hole21shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
1792 hole21shape->GetRmin(0));
1793
1794 hole21shape->Rmax(1) = hole21shape->GetRmax(0);
1795 hole21shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1796 hole21shape->GetRmax(1));
1797 hole21shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1798 hole21shape->GetZ(1));
1799
1800 hole21shape->Rmin(2) = kHole2RMin;
1801 hole21shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
1802 hole21shape->GetRmin(2));
1803 hole21shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1804 hole21shape->GetZ(2));
1805
1806 hole21shape->Rmin(3) = hole21shape->GetRmin(2);
1807 hole21shape->Rmax(3) = hole21shape->GetRmin(3);
1808 hole21shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1809 hole21shape->GetRmax(3));
1810
1811 TGeoPcon *hole22shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1812
1813 hole22shape->Rmin(0) = kHole2RMax;
1814 hole22shape->Rmax(0) = hole22shape->GetRmin(0);
1815 hole22shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1816 hole22shape->GetRmin(0));
1817
1818 hole22shape->Rmax(1) = hole22shape->GetRmax(0);
1819 hole22shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1820 hole22shape->GetRmax(1));
1821 hole22shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1822 hole22shape->GetZ(1));
1823
1824 hole22shape->Rmin(2) = kHole2RMin;
1825 hole22shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1826 hole22shape->GetRmin(2));
1827 hole22shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1828 hole22shape->GetZ(2));
1829
1830 hole22shape->Rmin(3) = hole22shape->GetRmin(2);
1831 hole22shape->Rmax(3) = hole22shape->GetRmin(3);
1832 hole22shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1833 hole22shape->GetRmax(3));
1834
1835 //
7d6c23de 1836 Double_t holePhi;
1837 holePhi = (kHole3Width/kHole3RMin)*TMath::RadToDeg();
1838
1839 TGeoPcon *hole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1840
1841 hole3shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
1842 hole3shape->Rmax(0) = hole3shape->GetRmin(0);
a30e33f0 1843 hole3shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta,
7d6c23de 1844 hole3shape->GetRmin(0));
1845
1846 hole3shape->Rmax(1) = hole3shape->GetRmax(0);
a30e33f0 1847 hole3shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1848 hole3shape->GetRmax(1));
a30e33f0 1849 hole3shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
7d6c23de 1850 hole3shape->GetZ(1));
1851
1852 hole3shape->Rmin(2) = kHole3RMin;
a30e33f0 1853 hole3shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
7d6c23de 1854 hole3shape->GetRmin(2));
a30e33f0 1855 hole3shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
7d6c23de 1856 hole3shape->GetZ(2));
1857
1858 hole3shape->Rmin(3) = hole3shape->GetRmin(2);
1859 hole3shape->Rmax(3) = hole3shape->GetRmin(3);
a30e33f0 1860 hole3shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1861 hole3shape->GetRmax(3));
1862
a30e33f0 1863 TGeoPcon *hole31shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1864
1865 hole31shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
1866 hole31shape->Rmax(0) = hole31shape->GetRmin(0);
1867 hole31shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
1868 hole31shape->GetRmin(0));
1869
1870 hole31shape->Rmax(1) = hole31shape->GetRmax(0);
1871 hole31shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1872 hole31shape->GetRmax(1));
1873 hole31shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1874 hole31shape->GetZ(1));
1875
1876 hole31shape->Rmin(2) = kHole3RMin;
1877 hole31shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
1878 hole31shape->GetRmin(2));
1879 hole31shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1880 hole31shape->GetZ(2));
1881
1882 hole31shape->Rmin(3) = hole31shape->GetRmin(2);
1883 hole31shape->Rmax(3) = hole31shape->GetRmin(3);
1884 hole31shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1885 hole31shape->GetRmax(3));
1886
1887 TGeoPcon *hole32shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1888
1889 hole32shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
1890 hole32shape->Rmax(0) = hole32shape->GetRmin(0);
1891 hole32shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1892 hole32shape->GetRmin(0));
1893
1894 hole32shape->Rmax(1) = hole32shape->GetRmax(0);
1895 hole32shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1896 hole32shape->GetRmax(1));
1897 hole32shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1898 hole32shape->GetZ(1));
1899
1900 hole32shape->Rmin(2) = kHole3RMin;
1901 hole32shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1902 hole32shape->GetRmin(2));
1903 hole32shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1904 hole32shape->GetZ(2));
1905
1906 hole32shape->Rmin(3) = hole32shape->GetRmin(2);
1907 hole32shape->Rmax(3) = hole32shape->GetRmin(3);
1908 hole32shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1909 hole32shape->GetRmax(3));
1910
1911 //
3a299c65 1912 holePhi = (kHole4Width/kHole4RMin)*TMath::RadToDeg();
1913
7d6c23de 1914 TGeoPcon *hole4shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1915
1916 hole4shape->Rmin(0) = kHole4RMin + kHole4DeltaR;
1917 hole4shape->Rmax(0) = hole4shape->GetRmin(0);
1918 hole4shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
1919 hole4shape->GetRmin(0));
1920
1921 hole4shape->Rmax(1) = hole4shape->GetRmax(0);
1922 hole4shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1923 hole4shape->GetRmax(1));
1924 hole4shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1925 hole4shape->GetZ(1));
1926
1927 hole4shape->Rmin(2) = kHole4RMin;
1928 hole4shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
1929 hole4shape->GetRmin(2));
1930 hole4shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1931 hole4shape->GetZ(2));
1932
1933 hole4shape->Rmin(3) = hole4shape->GetRmin(2);
1934 hole4shape->Rmax(3) = hole4shape->GetRmin(3);
1935 hole4shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1936 hole4shape->GetRmax(3));
1937
96eb8210 1938 // Cables to be put inside the holes: Pcon's
1939 // (fractions are manually computed from AliITSv11GeometrySDD::SDDCables
1940 TGeoPcon *hole1plastshape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1941
1942 hole1plastshape->Rmin(0) = hole1shape->GetRmin(0);
1943 hole1plastshape->Rmax(0) = hole1shape->GetRmax(0);
1944 hole1plastshape->Z(0) = hole1shape->GetZ(0);
1945
1946 hole1plastshape->Rmin(1) = hole1shape->GetRmin(1);
1947 hole1plastshape->Rmax(1) = hole1shape->GetRmax(1);
1948 hole1plastshape->Z(1) = hole1shape->GetZ(1);
1949
1950 dza = hole1plastshape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHolePlasticFrac;
1951
1952 hole1plastshape->Rmin(2) = dza;
1953 hole1plastshape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
1954 hole1plastshape->GetRmin(2));
1955 hole1plastshape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
1956 hole1plastshape->GetZ(2));
1957
1958 hole1plastshape->Rmin(3) = hole1plastshape->GetRmin(2);
1959 hole1plastshape->Rmax(3) = hole1plastshape->GetRmin(3);
1960 hole1plastshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1961 hole1plastshape->GetRmax(3));
1962
1963 TGeoPcon *hole1Cushape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1964
1965 hole1Cushape->Rmin(0) = hole1plastshape->GetRmin(2);
1966 hole1Cushape->Rmax(0) = hole1Cushape->GetRmin(0);
1967 hole1Cushape->Z(0) = hole1plastshape->GetZ(2);
1968
1969 dza = hole1Cushape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHoleCuFrac;
1970
1971 hole1Cushape->Rmin(1) = dza;
1972 hole1Cushape->Rmax(1) = hole1Cushape->GetRmax(0);
1973 hole1Cushape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
1974 hole1Cushape->GetRmin(1));
1975
1976 hole1Cushape->Rmax(2) = hole1Cushape->GetRmax(0);
1977 hole1Cushape->Rmin(2) = hole1Cushape->GetRmin(1);
1978 hole1Cushape->Z(2) = hole1plastshape->GetZ(3);
1979
1980 hole1Cushape->Rmin(3) = hole1Cushape->GetRmin(1);
1981 hole1Cushape->Rmax(3) = hole1Cushape->GetRmin(3);
1982 hole1Cushape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1983 hole1Cushape->GetRmax(3));
1984
1985 TGeoPcon *hole1glassshape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1986
1987 hole1glassshape->Rmin(0) = hole1Cushape->GetRmin(1);
1988 hole1glassshape->Rmax(0) = hole1glassshape->GetRmin(0);
1989 hole1glassshape->Z(0) = hole1Cushape->GetZ(1);
1990
1991 dza = hole1glassshape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHoleGlassFrac;
1992
1993 hole1glassshape->Rmin(1) = dza;
1994 hole1glassshape->Rmax(1) = hole1glassshape->GetRmax(0);
1995 hole1glassshape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
1996 hole1glassshape->GetRmin(1));
1997
1998 hole1glassshape->Rmax(2) = hole1glassshape->GetRmax(0);
1999 hole1glassshape->Rmin(2) = hole1glassshape->GetRmin(1);
2000 hole1glassshape->Z(2) = hole1Cushape->GetZ(3);
2001
2002 hole1glassshape->Rmin(3) = hole1glassshape->GetRmin(1);
2003 hole1glassshape->Rmax(3) = hole1glassshape->GetRmin(3);
2004 hole1glassshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
2005 hole1glassshape->GetRmax(3));
2006 //
2007 TGeoPcon *hole2plastshape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
2008
2009 hole2plastshape->Rmin(0) = hole2shape->GetRmin(0);
2010 hole2plastshape->Rmax(0) = hole2shape->GetRmax(0);
2011 hole2plastshape->Z(0) = hole2shape->GetZ(0);
2012
2013 hole2plastshape->Rmin(1) = hole2shape->GetRmin(1);
2014 hole2plastshape->Rmax(1) = hole2shape->GetRmax(1);
2015 hole2plastshape->Z(1) = hole2shape->GetZ(1);
2016
2017 dza = hole2plastshape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHolePlasticFrac;
2018
2019 hole2plastshape->Rmin(2) = dza;
2020 hole2plastshape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
2021 hole2plastshape->GetRmin(2));
2022 hole2plastshape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
2023 hole2plastshape->GetZ(2));
2024
2025 hole2plastshape->Rmin(3) = hole2plastshape->GetRmin(2);
2026 hole2plastshape->Rmax(3) = hole2plastshape->GetRmin(3);
2027 hole2plastshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
2028 hole2plastshape->GetRmax(3));
2029
2030 TGeoPcon *hole2Cushape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
2031
2032 hole2Cushape->Rmin(0) = hole2plastshape->GetRmin(2);
2033 hole2Cushape->Rmax(0) = hole2Cushape->GetRmin(0);
2034 hole2Cushape->Z(0) = hole2plastshape->GetZ(2);
2035
2036 dza = hole2Cushape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHoleCuFrac;
2037
2038 hole2Cushape->Rmin(1) = dza;
2039 hole2Cushape->Rmax(1) = hole2Cushape->GetRmax(0);
2040 hole2Cushape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
2041 hole2Cushape->GetRmin(1));
2042
2043 hole2Cushape->Rmax(2) = hole2Cushape->GetRmax(0);
2044 hole2Cushape->Rmin(2) = hole2Cushape->GetRmin(1);
2045 hole2Cushape->Z(2) = hole2plastshape->GetZ(3);
2046
2047 hole2Cushape->Rmin(3) = hole2Cushape->GetRmin(1);
2048 hole2Cushape->Rmax(3) = hole2Cushape->GetRmin(3);
2049 hole2Cushape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
2050 hole2Cushape->GetRmax(3));
2051
2052 TGeoPcon *hole2glassshape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
2053
2054 hole2glassshape->Rmin(0) = hole2Cushape->GetRmin(1);
2055 hole2glassshape->Rmax(0) = hole2glassshape->GetRmin(0);
2056 hole2glassshape->Z(0) = hole2Cushape->GetZ(1);
2057
2058 dza = hole2glassshape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHoleGlassFrac;
2059
2060 hole2glassshape->Rmin(1) = dza;
2061 hole2glassshape->Rmax(1) = hole2glassshape->GetRmax(0);
2062 hole2glassshape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
2063 hole2glassshape->GetRmin(1));
2064
2065 hole2glassshape->Rmax(2) = hole2glassshape->GetRmax(0);
2066 hole2glassshape->Rmin(2) = hole2glassshape->GetRmin(1);
2067 hole2glassshape->Z(2) = hole2Cushape->GetZ(3);
2068
2069 hole2glassshape->Rmin(3) = hole2glassshape->GetRmin(1);
2070 hole2glassshape->Rmax(3) = hole2glassshape->GetRmin(3);
2071 hole2glassshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
2072 hole2glassshape->GetRmax(3));
2073
2074
7d6c23de 2075 // Debug if requested
2076 if (GetDebug(1)) {
2077 coneshape->InspectShape();
2078 coneinsertshape->InspectShape();
2079 conefoamshape->InspectShape();
2080 hole1shape->InspectShape();
2081 hole2shape->InspectShape();
a30e33f0 2082 hole3shape->InspectShape();
2083 hole4shape->InspectShape();
7d6c23de 2084 }
2085
2086
2087 // We have the shapes: now create the real volumes
2088
2089 TGeoVolume *cfcone = new TGeoVolume("SDDCarbonFiberCone",
2090 coneshape,medSDDcf);
2091 cfcone->SetVisibility(kTRUE);
2092 cfcone->SetLineColor(4); // Blue
2093 cfcone->SetLineWidth(1);
2094 cfcone->SetFillColor(cfcone->GetLineColor());
2095 cfcone->SetFillStyle(4000); // 0% transparent
2096
2097 TGeoVolume *cfconeinsert = new TGeoVolume("SDDCarbonFiberConeInsert",
2098 coneinsertshape,medSDDste);
2099 cfconeinsert->SetVisibility(kTRUE);
2100 cfconeinsert->SetLineColor(2); // Red
2101 cfconeinsert->SetLineWidth(1);
2102 cfconeinsert->SetFillColor(cfconeinsert->GetLineColor());
2103 cfconeinsert->SetFillStyle(4050); // 50% transparent
2104
2105 TGeoVolume *cfconefoam = new TGeoVolume("SDDCarbonFiberConeFoam",
2106 conefoamshape,medSDDroh);
2107 cfconefoam->SetVisibility(kTRUE);
2108 cfconefoam->SetLineColor(7); // Light blue
2109 cfconefoam->SetLineWidth(1);
2110 cfconefoam->SetFillColor(cfconefoam->GetLineColor());
2111 cfconefoam->SetFillStyle(4050); // 50% transparent
2112
2113 TGeoVolume *hole1 = new TGeoVolume("SDDCableHole1",
2114 hole1shape,medSDDair);
2115 hole1->SetVisibility(kTRUE);
2116 hole1->SetLineColor(5); // Yellow
2117 hole1->SetLineWidth(1);
2118 hole1->SetFillColor(hole1->GetLineColor());
2119 hole1->SetFillStyle(4090); // 90% transparent
2120
a30e33f0 2121 TGeoVolume *hole11 = new TGeoVolume("SDDCableHole11",
2122 hole11shape,medSDDair);
2123 hole11->SetVisibility(kTRUE);
2124 hole11->SetLineColor(5); // Yellow
2125 hole11->SetLineWidth(1);
2126 hole11->SetFillColor(hole11->GetLineColor());
2127 hole11->SetFillStyle(4090); // 90% transparent
2128
2129 TGeoVolume *hole12 = new TGeoVolume("SDDCableHole12",
2130 hole12shape,medSDDair);
2131 hole12->SetVisibility(kTRUE);
2132 hole12->SetLineColor(5); // Yellow
2133 hole12->SetLineWidth(1);
2134 hole12->SetFillColor(hole12->GetLineColor());
2135 hole12->SetFillStyle(4090); // 90% transparent
2136
96eb8210 2137 TGeoVolume *hole1plast = new TGeoVolume("SDDCableHole1Plast",
2138 hole1plastshape,medSDDplast);
2139 hole1plast->SetVisibility(kTRUE);
2140 hole1plast->SetLineColor(kBlue);
2141 hole1plast->SetLineWidth(1);
2142 hole1plast->SetFillColor(hole1plast->GetLineColor());
2143 hole1plast->SetFillStyle(4090); // 90% transparent
2144
2145 TGeoVolume *hole1Cu = new TGeoVolume("SDDCableHole1Cu",
2146 hole1Cushape,medSDDCu);
2147 hole1Cu->SetVisibility(kTRUE);
2148 hole1Cu->SetLineColor(kRed);
2149 hole1Cu->SetLineWidth(1);
2150 hole1Cu->SetFillColor(hole1Cu->GetLineColor());
2151 hole1Cu->SetFillStyle(4090); // 90% transparent
2152
2153 TGeoVolume *hole1glass = new TGeoVolume("SDDCableHole1glass",
2154 hole1glassshape,medSDDglass);
2155 hole1glass->SetVisibility(kTRUE);
2156 hole1glass->SetLineColor(kGreen);
2157 hole1glass->SetLineWidth(1);
2158 hole1glass->SetFillColor(hole1glass->GetLineColor());
2159 hole1glass->SetFillStyle(4090); // 90% transparent
2160
7d6c23de 2161 TGeoVolume *hole2 = new TGeoVolume("SDDCableHole2",
2162 hole2shape,medSDDair);
2163 hole2->SetVisibility(kTRUE);
2164 hole2->SetLineColor(5); // Yellow
2165 hole2->SetLineWidth(1);
2166 hole2->SetFillColor(hole2->GetLineColor());
2167 hole2->SetFillStyle(4090); // 90% transparent
2168
a30e33f0 2169 TGeoVolume *hole21 = new TGeoVolume("SDDCableHole21",
2170 hole21shape,medSDDair);
2171 hole21->SetVisibility(kTRUE);
2172 hole21->SetLineColor(5); // Yellow
2173 hole21->SetLineWidth(1);
2174 hole21->SetFillColor(hole21->GetLineColor());
2175 hole21->SetFillStyle(4090); // 90% transparent
2176
2177 TGeoVolume *hole22 = new TGeoVolume("SDDCableHole22",
2178 hole22shape,medSDDair);
2179 hole22->SetVisibility(kTRUE);
2180 hole22->SetLineColor(5); // Yellow
2181 hole22->SetLineWidth(1);
2182 hole22->SetFillColor(hole22->GetLineColor());
2183 hole22->SetFillStyle(4090); // 90% transparent
2184
96eb8210 2185 TGeoVolume *hole2plast = new TGeoVolume("SDDCableHole2Plast",
2186 hole2plastshape,medSDDplast);
2187 hole2plast->SetVisibility(kTRUE);
2188 hole2plast->SetLineColor(kBlue);
2189 hole2plast->SetLineWidth(1);
2190 hole2plast->SetFillColor(hole2plast->GetLineColor());
2191 hole2plast->SetFillStyle(4090); // 90% transparent
2192
2193 TGeoVolume *hole2Cu = new TGeoVolume("SDDCableHole2Cu",
2194 hole2Cushape,medSDDCu);
2195 hole2Cu->SetVisibility(kTRUE);
2196 hole2Cu->SetLineColor(kRed);
2197 hole2Cu->SetLineWidth(1);
2198 hole2Cu->SetFillColor(hole2Cu->GetLineColor());
2199 hole2Cu->SetFillStyle(4090); // 90% transparent
2200
2201 TGeoVolume *hole2glass = new TGeoVolume("SDDCableHole2glass",
2202 hole2glassshape,medSDDglass);
2203 hole2glass->SetVisibility(kTRUE);
2204 hole2glass->SetLineColor(kGreen);
2205 hole2glass->SetLineWidth(1);
2206 hole2glass->SetFillColor(hole2glass->GetLineColor());
2207 hole2glass->SetFillStyle(4090); // 90% transparent
2208
7d6c23de 2209 TGeoVolume *hole3 = new TGeoVolume("SDDCableHole3",
2210 hole3shape,medSDDair);
2211 hole3->SetVisibility(kTRUE);
2212 hole3->SetLineColor(5); // Yellow
2213 hole3->SetLineWidth(1);
2214 hole3->SetFillColor(hole3->GetLineColor());
2215 hole3->SetFillStyle(4090); // 90% transparent
2216
a30e33f0 2217 TGeoVolume *hole31 = new TGeoVolume("SDDCableHole31",
2218 hole31shape,medSDDair);
2219 hole31->SetVisibility(kTRUE);
2220 hole31->SetLineColor(5); // Yellow
2221 hole31->SetLineWidth(1);
2222 hole31->SetFillColor(hole31->GetLineColor());
2223 hole31->SetFillStyle(4090); // 90% transparent
2224
2225 TGeoVolume *hole32 = new TGeoVolume("SDDCableHole32",
2226 hole32shape,medSDDair);
2227 hole32->SetVisibility(kTRUE);
2228 hole32->SetLineColor(5); // Yellow
2229 hole32->SetLineWidth(1);
2230 hole32->SetFillColor(hole32->GetLineColor());
2231 hole32->SetFillStyle(4090); // 90% transparent
2232
7d6c23de 2233 TGeoVolume *hole4 = new TGeoVolume("SDDCableHole4",
2234 hole4shape,medSDDair);
2235 hole4->SetVisibility(kTRUE);
2236 hole4->SetLineColor(5); // Yellow
2237 hole4->SetLineWidth(1);
2238 hole4->SetFillColor(hole4->GetLineColor());
2239 hole4->SetFillStyle(4090); // 90% transparent
2240
2241 // Mount up a cone
2242 cfconeinsert->AddNode(cfconefoam,1,0);
2243
96eb8210 2244 hole1->AddNode(hole1plast, 1, 0);
2245 hole1->AddNode(hole1Cu, 1, 0);
2246 hole1->AddNode(hole1glass, 1, 0);
2247
2248 hole2->AddNode(hole2plast, 1, 0);
2249 hole2->AddNode(hole2Cu, 1, 0);
2250 hole2->AddNode(hole2glass, 1, 0);
2251
7d6c23de 2252 for (Int_t i=0; i<12; i++) {
2253 Double_t phiH = i*30.0;
a30e33f0 2254 cfconefoam->AddNode(hole1 , i+1, new TGeoRotation("", 0, 0, phiH));
2255 cfcone->AddNode(hole11, i+1, new TGeoRotation("", 0, 0, phiH));
2256 cfcone->AddNode(hole12, i+1, new TGeoRotation("", 0, 0, phiH));
7d6c23de 2257 }
2258
2259 for (Int_t i=0; i<6; i++) {
2260 Double_t phiH = i*60.0;
a30e33f0 2261 cfconefoam->AddNode(hole2 , i+1, new TGeoRotation("", 0, 0, phiH));
2262 cfcone->AddNode(hole21, i+1, new TGeoRotation("", 0, 0, phiH));
2263 cfcone->AddNode(hole22, i+1, new TGeoRotation("", 0, 0, phiH));
7d6c23de 2264 }
2265
2266 for (Int_t i=0; i<kNHole3; i++) {
2267 Double_t phiH0 = 360./(Double_t)kNHole3;
2268 Double_t phiH = i*phiH0 + 0.5*phiH0;
a30e33f0 2269 cfconefoam->AddNode(hole3 , i+1, new TGeoRotation("", phiH, 0, 0));
2270 cfcone->AddNode(hole31, i+1, new TGeoRotation("", phiH, 0, 0));
2271 cfcone->AddNode(hole32, i+1, new TGeoRotation("", phiH, 0, 0));
7d6c23de 2272 }
a30e33f0 2273
2274 cfcone->AddNode(cfconeinsert,1,0);
2275
7d6c23de 2276/*
2277 for (Int_t i=0; i<kNHole4; i++) {
2278 Double_t phiH0 = 360./(Double_t)kNHole4;
2279 Double_t phiH = i*phiH0 + 0.25*phiH0;
2280 cfcone->AddNode(hole4, i+1, new TGeoRotation("", phiH, 0, 0));
2281 }
2282*/
3a299c65 2283 // Finally put everything in the mother volume
2284 moth->AddNode(cfcylinder,1,0);
7d6c23de 2285
2286 z = coneshape->Z(9);
3a299c65 2287 moth->AddNode(cfcone,1,new TGeoTranslation(0, 0, -z - kCylinderHalfLength));
2288 moth->AddNode(cfcone,2,new TGeoCombiTrans (0, 0, z + kCylinderHalfLength,
2289 new TGeoRotation("", 0, 180, 0) ));
7d6c23de 2290
7d6c23de 2291
2292 return;
172b0d90 2293}
7d6c23de 2294
172b0d90 2295//______________________________________________________________________
43aefea7 2296void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,const TGeoManager *mgr)
3a299c65 2297{
2298//
2299// Creates the SSD support cone and cylinder geometry. as a
2300// volume assembly and adds it to the mother volume
2301// (part of this code is taken or anyway inspired to SSDCone method
2302// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
2303//
2304// Input:
2305// moth : the TGeoVolume owing the volume structure
2306// mgr : the GeoManager (default gGeoManager)
2307// Output:
2308//
2309// Created: ??? Bjorn S. Nilsen
2310// Updated: 08 Mar 2008 Mario Sitta
2311//
2312// Technical data are taken from: "ITS Supporto Generale" (technical
2313// drawings ALR3-0743/1, ALR3-0743/1A and ALR3-0743/1B), "Supporto Generale
2314// Settore SSD" (technical drawings ALR3-0743/2A and ALR3-0743/2E), private
2315// communication with B. Giraudo
5e15508a 2316//
2317// Updated: 11 Apr 2008 Mario Sitta
2318// Measures from drawings give overlaps with SPD thermal shield wings,
2319// so the terminal part of the SSD cone was reduced
573a206f 2320//
2321// Updated: 30 Mar 2010 Mario Sitta
2322// Following M. van Leeuwen's suggestion on material budget, the thickness
2323// of the carbon fiber cylinder was increased from 0.6 to 0.625mm
3a299c65 2324
2325 // Dimensions of the Central cylinder and flanges
0801d201 2326 const Double_t kCylinderHalfLength = (1143.6/2) *fgkmm;
3a299c65 2327 const Double_t kCylinderOuterRadius = ( 595.0/2) *fgkmm;
573a206f 2328 const Double_t kCylinderThickness = 0.625*fgkmm;
3a299c65 2329 const Double_t kFoamHalfLength = (1020.0/2) *fgkmm;
2330 const Double_t kFoamThickness = 5.0 *fgkmm;
2331 const Double_t kFlangeHalfLength =
2332 (kCylinderHalfLength-kFoamHalfLength)/2.;
2333 const Double_t kFlangeInnerRadius = ( 563.0/2) *fgkmm;
2334 // Dimensions of the Cone
fd5b6398 2335 const Double_t kConeROuterMin = ( 957.0/2) *fgkmm;
2336 const Double_t kConeROuterMax = ( 997.0/2) *fgkmm;
3a299c65 2337 const Double_t kConeRInnerMin = ( 564.0/2) *fgkmm;
2338 const Double_t kConeRCurv1 = 10.0 *fgkmm;
2339 const Double_t kConeRCurv2 = 25.0 *fgkmm;
2340 const Double_t kConeCent1RCurv2 = ( 578.0/2) *fgkmm;
6b42825b 2341 const Double_t kConeCent2RCurv2 = ( 592.0/2) *fgkmm;
5e15508a 2342// const Double_t kConeZOuterRing = 47.0 *fgkmm;
2343// const Double_t kConeZOuterRingInside = 30.25*fgkmm;
2344// const Double_t kConeZInnerRing = 161.5 *fgkmm;
2345// const Double_t kConeZLength = 176.5 *fgkmm;
2346 const Double_t kConeZOuterRing = 38.5 *fgkmm;
2347 const Double_t kConeZOuterRingInside = 22.2 *fgkmm;
2348 const Double_t kConeZInnerRing = 153.0 *fgkmm;
2349 const Double_t kConeZLength = 168.0 *fgkmm;
3a299c65 2350 const Double_t kConeZPosition = kConeZLength + kCylinderHalfLength;
2351 const Double_t kConeThickness = 13.0 *fgkmm; // Cone thickness
81adc4e0 2352 const Double_t kConeTheta = 39.1 *fgkDegree; // Cone angle
3a299c65 2353 const Double_t kSinConeTheta =
2354 TMath::Sin(kConeTheta*TMath::DegToRad());
2355 const Double_t kCosConeTheta =
2356 TMath::Cos(kConeTheta*TMath::DegToRad());
2357 // Dimensions of the Foam cores
2358 const Double_t kConeFoam1Length = 112.3 *fgkmm;
2359 const Double_t kConeFoam2Length = 58.4 *fgkmm;
2360 // Dimensions of the Cone Holes
2361 const Double_t kCoolingHoleWidth = 40.0 *fgkmm;
2362 const Double_t kCoolingHoleHight = 30.0 *fgkmm;
2363 const Double_t kCoolingHoleRmin = 350.0 *fgkmm;
2364 const Double_t kCoolingHolePhi = 45.0 *fgkDegree;
2365 const Double_t kMountingHoleWidth = 20.0 *fgkmm;
2366 const Double_t kMountingHoleHight = 20.0 *fgkmm;
2367 const Double_t kMountingHoleRmin = 317.5 *fgkmm;
2368 const Double_t kMountingHolePhi = 60.0 *fgkDegree;
2369 const Double_t kCableHoleRin = ( 800.0/2) *fgkmm;
2370 const Double_t kCableHoleRout = ( 920.0/2) *fgkmm;
2371 const Double_t kCableHoleWidth = 200.0 *fgkmm;
2372// const Double_t kCableHoleAngle = 42.0 *fgkDegree;
2373 // Dimensions of the Cone Wings
2374 const Double_t kWingRmax = 527.5 *fgkmm;
2375 const Double_t kWingWidth = 70.0 *fgkmm;
2376 const Double_t kWingHalfThick = ( 10.0/2) *fgkmm;
2377 const Double_t kThetaWing = 45.0 *fgkDegree;
2378 // Dimensions of the SSD-SDD Mounting Brackets
989ee428 2379 const Double_t kBracketRmin = ( 541.0/2) *fgkmm;// See SDD ROutMin
3a299c65 2380 const Double_t kBracketRmax = ( 585.0/2) *fgkmm;
2381 const Double_t kBracketHalfLength = ( 4.0/2) *fgkmm;
2382 const Double_t kBracketPhi = (70.*fgkmm/kBracketRmax)*fgkRadian;
2383 // Common data
2384 const Double_t kCFThickness = 0.75*fgkmm; //Carb. fib. thick.
2385
2386
2387 // Local variables
2388 Double_t rmin1, rmin2, rmax, z;
2389
2390 //
2391 //Begin_Html
2392 /*
2393 <img src="picts/ITS/file_name.gif">
2394 <P>
2395 <FONT FACE'"TIMES">
2396 ITS SSD central support and thermal shield cylinder.
2397 </FONT>
2398 </P>
2399 */
2400 //End_Html
2401 //
2402
2403 // Central cylinder with its internal foam and the lateral flanges:
2404 // a carbon fiber Pcon which contains a rohacell Tube and two
2405 // stesalite Cone's
2406 TGeoPcon *externalcylshape = new TGeoPcon(0,360,4);
2407
2408 rmax = kCylinderOuterRadius;
2409 rmin1 = kFlangeInnerRadius - kCylinderThickness;
2410 rmin2 = rmax - 2*kCylinderThickness - kFoamThickness;
2411 externalcylshape->DefineSection(0,-kCylinderHalfLength,rmin1,rmax);
2412 externalcylshape->DefineSection(1,-kFoamHalfLength ,rmin2,rmax);
2413 externalcylshape->DefineSection(2, kFoamHalfLength ,rmin2,rmax);
2414 externalcylshape->DefineSection(3, kCylinderHalfLength,rmin1,rmax);
2415
2416 rmax = kCylinderOuterRadius - kCylinderThickness;
2417 rmin1 = rmax - kFoamThickness;
2418 TGeoTube *foamshape = new TGeoTube(rmin1,rmax,kFoamHalfLength);
2419
2420 rmax = kCylinderOuterRadius - kCylinderThickness;
2421 rmin1 = rmax - kFoamThickness;
2422 rmin2 = kFlangeInnerRadius;
2423 TGeoCone *flangeshape = new TGeoCone(kFlangeHalfLength,
2424 rmin1,rmax,rmin2,rmax);
2425
2426
2427 // We have the shapes: now create the real volumes
2428
2429 TGeoMedium *medSSDcf = mgr->GetMedium("ITS_SSD C (M55J)$");
2430 TGeoMedium *medSSDair = mgr->GetMedium("ITS_SSD AIR$");
2431 TGeoMedium *medSSDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
2432 TGeoMedium *medSSDroh = mgr->GetMedium("ITS_ROHACELL$");
2433 TGeoMedium *medSSDal = mgr->GetMedium("ITS_ALUMINUM$");
2434
2435 TGeoVolume *cfcylinder = new TGeoVolume("SSDexternalcylinder",
2436 externalcylshape,medSSDcf);
2437 cfcylinder->SetVisibility(kTRUE);
2438 cfcylinder->SetLineColor(4); // blue
2439 cfcylinder->SetLineWidth(1);
2440 cfcylinder->SetFillColor(cfcylinder->GetLineColor());
2441 cfcylinder->SetFillStyle(4000); // 0% transparent
2442
2443 TGeoVolume *foamcylinder = new TGeoVolume("SSDfoamcylinder",
2444 foamshape,medSSDroh);
2445 foamcylinder->SetVisibility(kTRUE);
2446 foamcylinder->SetLineColor(3); // green
2447 foamcylinder->SetLineWidth(1);
2448 foamcylinder->SetFillColor(foamcylinder->GetLineColor());
2449 foamcylinder->SetFillStyle(4050); // 50% transparent
2450
2451 TGeoVolume *flangecylinder = new TGeoVolume("SSDflangecylinder",
2452 flangeshape,medSSDste);
2453 flangecylinder->SetVisibility(kTRUE);
2454 flangecylinder->SetLineColor(2); // red
2455 flangecylinder->SetLineWidth(1);
2456 flangecylinder->SetFillColor(flangecylinder->GetLineColor());
2457 flangecylinder->SetFillStyle(4050); // 50% transparent
2458
2459 // Mount up the cylinder
2460 cfcylinder->AddNode(foamcylinder,1,0);
2461 cfcylinder->AddNode(flangecylinder,1,
2462 new TGeoTranslation(0, 0, kFoamHalfLength+kFlangeHalfLength));
2463 cfcylinder->AddNode(flangecylinder,2,new TGeoCombiTrans(
2464 0, 0, -kFoamHalfLength-kFlangeHalfLength,
2465 new TGeoRotation("",0,180,0) ) );
2466
2467
2468 // The whole Cone as an assembly
2469 TGeoVolumeAssembly *vC = new TGeoVolumeAssembly("ITSssdCone");
2470
2471
2472 // SSD Support Cone with its internal inserts: a carbon fiber Pcon
2473 // with holes which contains a stesalite Pcon which on turn contains a
2474 // rohacell Pcon
2475 TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 12);
2476
2477 coneshape->Z(0) = 0.0;
2478 coneshape->Rmin(0) = kConeROuterMin;
2479 coneshape->Rmax(0) = kConeROuterMax;
2480
2481 coneshape->Z(1) = kConeZOuterRingInside - kConeRCurv1;
2482 coneshape->Rmin(1) = coneshape->GetRmin(0);
2483 coneshape->Rmax(1) = coneshape->GetRmax(0);
2484
2485 coneshape->Z(2) = kConeZOuterRingInside;
2486 coneshape->Rmin(2) = coneshape->GetRmin(1) - kConeRCurv1;
2487 coneshape->Rmax(2) = coneshape->GetRmax(0);
2488
2489 coneshape->Z(3) = coneshape->GetZ(2);
2490 coneshape->Rmax(3) = coneshape->GetRmax(0);
2491
2492 coneshape->Z(4) = kConeZOuterRing - kConeRCurv1;
2493 coneshape->Rmax(4) = coneshape->GetRmax(0);
2494
2495 coneshape->Z(5) = kConeZOuterRing;
2496 coneshape->Rmax(5) = coneshape->GetRmax(4) - kConeRCurv1;
2497
2498 coneshape->Z(6) = coneshape->GetZ(5);
2499
2500 RadiusOfCurvature(kConeRCurv2,90.0,kConeZInnerRing,kConeCent1RCurv2,
2501 90.0-kConeTheta,z,rmin1);
2502 coneshape->Z(7) = z;
2503 coneshape->Rmin(7) = rmin1;
2504
2505 coneshape->Rmin(3) = RminFromZpCone(coneshape,7,90.-kConeTheta,
2506 coneshape->GetZ(3));
2507
2508 coneshape->Rmin(4) = RminFrom2Points(coneshape,3,7,coneshape->GetZ(4));
2509
2510 coneshape->Rmin(5) = RminFrom2Points(coneshape,3,7,coneshape->GetZ(5));
2511
2512 coneshape->Rmin(6) = coneshape->GetRmin(5);
2513
2514 coneshape->Z(8) = kConeZInnerRing;
2515 coneshape->Rmin(8) = kConeCent1RCurv2;
2516
2517 coneshape->Z(9) = coneshape->GetZ(8);
2518 coneshape->Rmin(9) = kConeRInnerMin;
2519
2520 RadiusOfCurvature(kConeRCurv2,90.0,kConeZLength,kConeCent2RCurv2,
2521 90.0-kConeTheta,z,rmax);
2522
2523 coneshape->Z(10) = z;
2524 coneshape->Rmin(10) = coneshape->GetRmin(9);
2525 coneshape->Rmax(10) = rmax;
2526
2527 coneshape->Rmax(6) = RmaxFromZpCone(coneshape,10,90.-kConeTheta,
2528 coneshape->GetZ(6));
2529
2530 coneshape->Rmax(7) = RmaxFrom2Points(coneshape,6,10,coneshape->GetZ(7));
2531
2532 coneshape->Rmax(8) = RmaxFrom2Points(coneshape,6,10,coneshape->GetZ(8));
2533
2534 coneshape->Rmax(9) = coneshape->GetRmax(8);
2535
2536 coneshape->Z(11) = kConeZLength;
2537 coneshape->Rmin(11) = coneshape->GetRmin(10);
2538 coneshape->Rmax(11) = kConeCent2RCurv2;
2539
2540 // SSD Cone Insert: another Pcon
2541 Double_t x0, y0, x1, y1, x2, y2;
2542 TGeoPcon *coneinsertshape = new TGeoPcon(0.0,360.0,12);
2543
2544 coneinsertshape->Z(0) = coneshape->GetZ(0) + kCFThickness;
2545 coneinsertshape->Rmin(0) = coneshape->GetRmin(0) + kCFThickness;
2546 coneinsertshape->Rmax(0) = coneshape->GetRmax(0) - kCFThickness;
2547
2548 x0 = coneshape->GetZ(0); y0 = coneshape->GetRmin(0);
2549 x1 = coneshape->GetZ(1); y1 = coneshape->GetRmin(1);
2550 x2 = coneshape->GetZ(2); y2 = coneshape->GetRmin(2);
2551 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2552 coneinsertshape->Z(1) = z;
2553 coneinsertshape->Rmin(1) = rmin1;
2554 coneinsertshape->Rmax(1) = coneinsertshape->GetRmax(0);
2555
2556 x0 = coneshape->GetZ(1); y0 = coneshape->GetRmin(1);
2557 x1 = coneshape->GetZ(2); y1 = coneshape->GetRmin(2);
2558 x2 = coneshape->GetZ(3); y2 = coneshape->GetRmin(3);
2559 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2560 coneinsertshape->Z(2) = z;
2561 coneinsertshape->Rmin(2) = rmin1;
2562 coneinsertshape->Rmax(2) = coneinsertshape->GetRmax(1);
2563
2564 x0 = coneshape->GetZ(2); y0 = coneshape->GetRmin(2);
2565 x1 = coneshape->GetZ(3); y1 = coneshape->GetRmin(3);
2566 x2 = coneshape->GetZ(4); y2 = coneshape->GetRmin(4);
2567 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2568 coneinsertshape->Z(3) = z;
2569 coneinsertshape->Rmin(3) = rmin1;
2570 coneinsertshape->Rmax(3) = coneinsertshape->GetRmax(2);
2571
2572 x0 = coneshape->GetZ(3); y0 = coneshape->GetRmax(3);
2573 x1 = coneshape->GetZ(4); y1 = coneshape->GetRmax(4);
2574 x2 = coneshape->GetZ(5); y2 = coneshape->GetRmax(5);
2575 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2576 coneinsertshape->Z(4) = z;
2577 coneinsertshape->Rmax(4) = rmax;
2578
2579 x0 = coneshape->GetZ(4); y0 = coneshape->GetRmax(4);
2580 x1 = coneshape->GetZ(5); y1 = coneshape->GetRmax(5);
2581 x2 = coneshape->GetZ(6); y2 = coneshape->GetRmax(6);
2582 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2583 coneinsertshape->Z(5) = z;
2584 coneinsertshape->Rmax(5) = rmax;
2585
2586 x0 = coneshape->GetZ(5); y0 = coneshape->GetRmax(5);
2587 x1 = coneshape->GetZ(6); y1 = coneshape->GetRmax(6);
2588 x2 = coneshape->GetZ(7); y2 = coneshape->GetRmax(7);
2589 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2590 coneinsertshape->Z(6) = z;
2591 coneinsertshape->Rmax(6) = rmax;
2592
2593 x0 = coneshape->GetZ(6); y0 = coneshape->GetRmin(6);
2594 x1 = coneshape->GetZ(7); y1 = coneshape->GetRmin(7);
2595 x2 = coneshape->GetZ(8); y2 = coneshape->GetRmin(8);
2596 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2597 coneinsertshape->Z(7) = z;
2598 coneinsertshape->Rmin(7) = rmin1;
2599
2600 coneinsertshape->Rmin(4) = RminFrom2Points(coneinsertshape,3,7,
2601 coneinsertshape->GetZ(4));
2602
2603 coneinsertshape->Rmin(5) = RminFrom2Points(coneinsertshape,3,7,
2604 coneinsertshape->GetZ(5));
2605
2606 coneinsertshape->Rmin(6) = coneinsertshape->GetRmin(5);
2607
2608 x0 = coneshape->GetZ(7); y0 = coneshape->GetRmin(7);
2609 x1 = coneshape->GetZ(8); y1 = coneshape->GetRmin(8);
2610 x2 = coneshape->GetZ(9); y2 = coneshape->GetRmin(9);
2611 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2612 coneinsertshape->Z(8) = z;
2613 coneinsertshape->Rmin(8) = rmin1;
2614
2615 x0 = coneshape->GetZ( 8); y0 = coneshape->GetRmin( 8);
2616 x1 = coneshape->GetZ( 9); y1 = coneshape->GetRmin( 9);
2617 x2 = coneshape->GetZ(10); y2 = coneshape->GetRmin(10);
2618 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2619 coneinsertshape->Z(9) = z;
2620 coneinsertshape->Rmin(9) = rmin1;
2621
2622 x0 = coneshape->GetZ( 9); y0 = coneshape->GetRmax( 9);
2623 x1 = coneshape->GetZ(10); y1 = coneshape->GetRmax(10);
2624 x2 = coneshape->GetZ(11); y2 = coneshape->GetRmax(11);
2625 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2626 coneinsertshape->Z(10) = z;
2627 coneinsertshape->Rmax(10) = rmax;
2628 coneinsertshape->Rmin(10) = coneinsertshape->GetRmin(9);
2629
2630 coneinsertshape->Rmax(7) = RmaxFrom2Points(coneinsertshape,6,10,
2631 coneinsertshape->GetZ(7));
2632
2633 coneinsertshape->Rmax(8) = RmaxFrom2Points(coneinsertshape,6,10,
2634 coneinsertshape->GetZ(8));
2635
2636 coneinsertshape->Rmax(9) = coneinsertshape->GetRmax(8);
2637
2638 x0 = coneshape->GetZ(10); y0 = coneshape->GetRmax(10);
2639 x1 = coneshape->GetZ(11); y1 = coneshape->GetRmax(11);
2640 x2 = coneshape->GetZ(11); y2 = coneshape->GetRmin(11);
2641 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2642 coneinsertshape->Z(11) = z;
2643 coneinsertshape->Rmax(11) = rmax;
2644 coneinsertshape->Rmin(11) = coneinsertshape->GetRmin(10);
2645
2646 // SSD Cone Foams: two other Pcon's
2647 TGeoPcon *conefoam1shape = new TGeoPcon(0.0, 360.0, 4);
2648
2649 conefoam1shape->Z(0) = coneinsertshape->GetZ(3);
2650 conefoam1shape->Rmin(0) = coneinsertshape->GetRmin(3);
2651 conefoam1shape->Rmax(0) = conefoam1shape->GetRmin(0);
2652
2653 conefoam1shape->Rmax(1) = conefoam1shape->GetRmax(0);
2654 conefoam1shape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2655 conefoam1shape->GetRmax(1));
2656 conefoam1shape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2657 conefoam1shape->GetZ(1));
2658
2659 Double_t t = kConeThickness - 2*kCFThickness;
2660 conefoam1shape->Rmin(2) = conefoam1shape->GetRmax(0) -
2661 (kConeFoam1Length*kCosConeTheta - t*kSinConeTheta);
2662 conefoam1shape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2663 conefoam1shape->GetRmin(2));
2664 conefoam1shape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2665 conefoam1shape->GetZ(2));
2666
2667 conefoam1shape->Rmin(3) = conefoam1shape->GetRmin(2);
2668 conefoam1shape->Rmax(3) = conefoam1shape->GetRmin(3);
2669 conefoam1shape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2670 conefoam1shape->GetRmax(3));
2671
2672 TGeoPcon *conefoam2shape = new TGeoPcon(0.0, 360.0, 4);
2673
2674 conefoam2shape->Z(3) = coneinsertshape->GetZ(10);
2675 conefoam2shape->Rmin(3) = coneinsertshape->GetRmax(10);
2676 conefoam2shape->Rmax(3) = conefoam2shape->GetRmin(3);
2677
2678 conefoam2shape->Rmin(2) = conefoam2shape->GetRmin(3);
2679 conefoam2shape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2680 conefoam2shape->GetRmin(2));
2681 conefoam2shape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2682 conefoam2shape->GetZ(2));
2683
2684 conefoam2shape->Rmin(0) = conefoam2shape->GetRmax(2) +
2685 (kConeFoam2Length*kCosConeTheta - t*kSinConeTheta);
2686 conefoam2shape->Rmax(0) = conefoam2shape->GetRmin(0);
2687 conefoam2shape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2688 conefoam2shape->GetRmin(0));
2689
2690 conefoam2shape->Rmax(1) = conefoam2shape->GetRmax(0);
2691 conefoam2shape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2692 conefoam2shape->GetRmax(1));
2693 conefoam2shape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2694 conefoam2shape->GetZ(1));
2695
2696 // SSD Cone Holes: Pcon's
a30e33f0 2697 // A single hole volume gives an overlap with coneinsert, so
2698 // three contiguous volumes are created: one to be put in coneinsert
2699 // and two in the cone carbon fiber envelope
3a299c65 2700 Double_t holePhi;
2701 holePhi = (kCoolingHoleWidth/kCoolingHoleRmin)*TMath::RadToDeg();
2702
2703 TGeoPcon *coolingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4);
2704
2705 coolingholeshape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
2706 coolingholeshape->Rmax(0) = coolingholeshape->GetRmin(0);
a30e33f0 2707 coolingholeshape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
3a299c65 2708 coolingholeshape->GetRmin(0));
2709
2710 coolingholeshape->Rmax(1) = coolingholeshape->GetRmax(0);
a30e33f0 2711 coolingholeshape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
3a299c65 2712 coolingholeshape->GetRmax(1));
a30e33f0 2713 coolingholeshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
3a299c65 2714 coolingholeshape->GetZ(1));
2715
2716 coolingholeshape->Rmin(2) = kCoolingHoleRmin;
a30e33f0 2717 coolingholeshape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
3a299c65 2718 coolingholeshape->GetRmin(2));
a30e33f0 2719 coolingholeshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
3a299c65 2720 coolingholeshape->GetZ(2));
2721
2722 coolingholeshape->Rmin(3) = coolingholeshape->GetRmin(2);
2723 coolingholeshape->Rmax(3) = coolingholeshape->GetRmin(3);
a30e33f0 2724 coolingholeshape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
3a299c65 2725 coolingholeshape->GetRmax(3));
2726
a30e33f0 2727 TGeoPcon *coolinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2728
2729 coolinghole2shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
2730 coolinghole2shape->Rmax(0) = coolinghole2shape->GetRmin(0);
2731 coolinghole2shape->Z(0) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2732 coolinghole2shape->GetRmin(0));
2733
2734 coolinghole2shape->Rmax(1) = coolinghole2shape->GetRmax(0);
2735 coolinghole2shape->Z(1) = coolingholeshape->GetZ(0);
2736 coolinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
2737 coolinghole2shape->GetZ(1));
2738
2739 coolinghole2shape->Rmin(2) = kCoolingHoleRmin;
2740 coolinghole2shape->Z(2) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2741 coolinghole2shape->GetRmin(2));
2742 coolinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2743 coolinghole2shape->GetZ(2));
2744
2745 coolinghole2shape->Rmin(3) = coolinghole2shape->GetRmin(2);
2746 coolinghole2shape->Rmax(3) = coolinghole2shape->GetRmin(3);
2747 coolinghole2shape->Z(3) = coolingholeshape->GetZ(2);
2748
2749 TGeoPcon *coolinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2750
2751 coolinghole3shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
2752 coolinghole3shape->Rmax(0) = coolinghole3shape->GetRmin(0);
2753 coolinghole3shape->Z(0) = coolingholeshape->GetZ(1);
2754
2755 coolinghole3shape->Rmax(1) = coolinghole3shape->GetRmax(0);
2756 coolinghole3shape->Z(1) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2757 coolinghole3shape->GetRmax(1));
2758 coolinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2759 coolinghole3shape->GetZ(1));
2760
2761 coolinghole3shape->Rmin(2) = kCoolingHoleRmin;
2762 coolinghole3shape->Z(2) = coolingholeshape->GetZ(3);
2763 coolinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
2764 coolinghole3shape->GetZ(2));
2765
2766 coolinghole3shape->Rmin(3) = coolinghole3shape->GetRmin(2);
2767 coolinghole3shape->Rmax(3) = coolinghole3shape->GetRmin(3);
2768 coolinghole3shape->Z(3) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2769 coolinghole3shape->GetRmax(3));
2770
2771 //
3a299c65 2772 holePhi = (kMountingHoleWidth/kMountingHoleRmin)*TMath::RadToDeg();
2773
2774 TGeoPcon *mountingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4);
2775
2776 mountingholeshape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
2777 mountingholeshape->Rmax(0) = mountingholeshape->GetRmin(0);
2778 mountingholeshape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2779 mountingholeshape->GetRmin(0));
2780
2781 mountingholeshape->Rmin(1) = kMountingHoleRmin;
2782 mountingholeshape->Rmax(1) = mountingholeshape->GetRmax(0);
2783 mountingholeshape->Z(1) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2784 mountingholeshape->GetRmin(1));
2785
2786 mountingholeshape->Rmin(2) = mountingholeshape->GetRmin(1);
2787 mountingholeshape->Rmax(2) = mountingholeshape->GetRmax(1);
2788 mountingholeshape->Z(2) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2789 mountingholeshape->GetRmax(2));
2790
2791 mountingholeshape->Rmin(3) = mountingholeshape->GetRmin(2);
2792 mountingholeshape->Rmax(3) = mountingholeshape->GetRmin(3);
2793 mountingholeshape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2794 mountingholeshape->GetRmax(3));
2795
2796 TGeoPcon *mountinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2797
2798 mountinghole2shape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
2799 mountinghole2shape->Rmax(0) = mountingholeshape->GetRmin(0);
2800 mountinghole2shape->Z(0) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2801 mountinghole2shape->GetRmin(0));
2802
2803 mountinghole2shape->Rmax(1) = mountinghole2shape->GetRmax(0);
2804 mountinghole2shape->Z(1) = mountingholeshape->Z(0);
2805 mountinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
2806 mountinghole2shape->GetZ(1));
2807
2808 mountinghole2shape->Rmin(2) = kMountingHoleRmin;
2809 mountinghole2shape->Z(2) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2810 mountinghole2shape->GetRmin(2));
2811 mountinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2812 mountinghole2shape->GetZ(2));
2813
2814 mountinghole2shape->Rmin(3) = mountinghole2shape->Rmin(2);
2815 mountinghole2shape->Rmax(3) = mountinghole2shape->Rmin(3);
2816 mountinghole2shape->Z(3) = mountingholeshape->Z(1);
2817
2818 TGeoPcon *mountinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2819
2820 mountinghole3shape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
2821 mountinghole3shape->Rmax(0) = mountingholeshape->GetRmin(0);
2822 mountinghole3shape->Z(0) = mountingholeshape->GetZ(2);
2823
2824 mountinghole3shape->Rmax(1) = mountinghole3shape->GetRmax(0);
2825 mountinghole3shape->Z(1) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2826 mountinghole3shape->GetRmax(1));
2827 mountinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2828 mountinghole3shape->GetZ(1));
2829
2830 mountinghole3shape->Rmin(2) = kMountingHoleRmin;
2831 mountinghole3shape->Z(2) = mountingholeshape->Z(3);
2832 mountinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
2833 mountinghole3shape->GetZ(2));
2834
2835 mountinghole3shape->Rmin(3) = mountinghole3shape->Rmin(2);
2836 mountinghole3shape->Rmax(3) = mountinghole3shape->Rmin(3);
2837 mountinghole3shape->Z(3) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2838 mountinghole3shape->GetRmax(3));
2839
2840 // The Cable Hole is even more complicated, a Composite Shape
2841 // is unavoidable here (gosh!)
2842 TGeoPcon *coneshapecopy = new TGeoPcon("conecopy",0.0, 360.0, 12);
2843
2844 for (Int_t i=0; i<12; i++) {
2845 coneshapecopy->Rmin(i) = coneshape->GetRmin(i);
2846 coneshapecopy->Rmax(i) = coneshape->GetRmax(i);
2847 coneshapecopy->Z(i) = coneshape->GetZ(i);
2848 }
2849
2850 holePhi = (kCableHoleWidth/kCableHoleRout)*TMath::RadToDeg();
2851 TGeoConeSeg *chCS = new TGeoConeSeg("chCS", 0.5*kConeZLength,
2852 kCableHoleRin, kCableHoleRout,
2853 kCableHoleRin, kCableHoleRout,
2854 -0.5*holePhi, 0.5*holePhi);
2855
2856 TGeoCompositeShape *cableholeshape = new TGeoCompositeShape(
2857 "SSDCableHoleShape",
2858 "conecopy*chCS");
2859
2860 if(GetDebug(1)){
2861 chCS->InspectShape();
2862 cableholeshape->InspectShape();
2863 }
2864
2865 // SSD Cone Wings: Tube and TubeSeg shapes
2866 Double_t angleWideWing, angleWideWingThickness;
2867 angleWideWing = (kWingWidth/kWingRmax)*TMath::RadToDeg();
2868 angleWideWingThickness = (kCFThickness/kWingRmax)*TMath::RadToDeg();
2869
2870 TGeoTubeSeg *wingshape = new TGeoTubeSeg(kConeROuterMax, kWingRmax,
2871 kWingHalfThick,
2872 0, angleWideWing);
2873
2874 TGeoTubeSeg *winginsertshape = new TGeoTubeSeg(kConeROuterMax,
2875 kWingRmax-kCFThickness,
2876 kWingHalfThick-kCFThickness,
2877 angleWideWingThickness,
2878 angleWideWing-angleWideWingThickness);
2879
2880 // SDD support plate, SSD side (Mounting Bracket): a TubeSeg
2881 TGeoTubeSeg *bracketshape = new TGeoTubeSeg(kBracketRmin, kBracketRmax,
2882 kBracketHalfLength, -kBracketPhi/2, kBracketPhi/2);
2883
2884
2885 // We have the shapes: now create the real volumes
2886
2887 TGeoVolume *cfcone = new TGeoVolume("SSDCarbonFiberCone",
2888 coneshape,medSSDcf);
2889 cfcone->SetVisibility(kTRUE);
2890 cfcone->SetLineColor(4); // Blue
2891 cfcone->SetLineWidth(1);
2892 cfcone->SetFillColor(cfcone->GetLineColor());
2893 cfcone->SetFillStyle(4000); // 0% transparent
2894
2895 TGeoVolume *cfconeinsert = new TGeoVolume("SSDCarbonFiberConeInsert",
2896 coneinsertshape,medSSDste);
2897 cfconeinsert->SetVisibility(kTRUE);
2898 cfconeinsert->SetLineColor(2); // Red
2899 cfconeinsert->SetLineWidth(1);
2900 cfconeinsert->SetFillColor(cfconeinsert->GetLineColor());
2901 cfconeinsert->SetFillStyle(4050); // 50% transparent
2902
2903 TGeoVolume *cfconefoam1 = new TGeoVolume("SSDCarbonFiberConeFoam1",
2904 conefoam1shape,medSSDroh);
2905 cfconefoam1->SetVisibility(kTRUE);
2906 cfconefoam1->SetLineColor(3); // Green
2907 cfconefoam1->SetLineWidth(1);
2908 cfconefoam1->SetFillColor(cfconefoam1->GetLineColor());
2909 cfconefoam1->SetFillStyle(4050); // 50% transparent
2910
2911 TGeoVolume *cfconefoam2 = new TGeoVolume("SSDCarbonFiberConeFoam2",
2912 conefoam2shape,medSSDroh);
2913 cfconefoam2->SetVisibility(kTRUE);
2914 cfconefoam2->SetLineColor(3); // Green
2915 cfconefoam2->SetLineWidth(1);
2916 cfconefoam2->SetFillColor(cfconefoam2->GetLineColor());
2917 cfconefoam2->SetFillStyle(4050); // 50% transparent
2918
2919 TGeoVolume *coolinghole = new TGeoVolume("SSDCoolingHole",
2920 coolingholeshape,medSSDair);
2921 coolinghole->SetVisibility(kTRUE);
2922 coolinghole->SetLineColor(5); // Yellow
2923 coolinghole->SetLineWidth(1);
2924 coolinghole->SetFillColor(coolinghole->GetLineColor());
2925 coolinghole->SetFillStyle(4090); // 90% transparent
2926
a30e33f0 2927 TGeoVolume *coolinghole2 = new TGeoVolume("SSDCoolingHole2",
2928 coolinghole2shape,medSSDair);
2929 coolinghole2->SetVisibility(kTRUE);
2930 coolinghole2->SetLineColor(5); // Yellow
2931 coolinghole2->SetLineWidth(1);
2932 coolinghole2->SetFillColor(coolinghole2->GetLineColor());
2933 coolinghole2->SetFillStyle(4090); // 90% transparent
2934
2935 TGeoVolume *coolinghole3 = new TGeoVolume("SSDCoolingHole3",
2936 coolinghole3shape,medSSDair);
2937 coolinghole3->SetVisibility(kTRUE);
2938 coolinghole3->SetLineColor(5); // Yellow
2939 coolinghole3->SetLineWidth(1);
2940 coolinghole3->SetFillColor(coolinghole3->GetLineColor());
2941 coolinghole3->SetFillStyle(4090); // 90% transparent
2942
3a299c65 2943 TGeoVolume *mountinghole = new TGeoVolume("SSDMountingHole",
2944 mountingholeshape,medSSDair);
2945 mountinghole->SetVisibility(kTRUE);
2946 mountinghole->SetLineColor(5); // Yellow
2947 mountinghole->SetLineWidth(1);
2948 mountinghole->SetFillColor(mountinghole->GetLineColor());
2949 mountinghole->SetFillStyle(4090); // 90% transparent
2950
2951 TGeoVolume *mountinghole2 = new TGeoVolume("SSDMountingHole2",
2952 mountinghole2shape,medSSDair);
2953 mountinghole2->SetVisibility(kTRUE);
2954 mountinghole2->SetLineColor(5); // Yellow
2955 mountinghole2->SetLineWidth(1);
2956 mountinghole2->SetFillColor(mountinghole2->GetLineColor());
2957 mountinghole2->SetFillStyle(4090); // 90% transparent
2958
2959 TGeoVolume *mountinghole3 = new TGeoVolume("SSDMountingHole3",
2960 mountinghole3shape,medSSDair);
2961 mountinghole3->SetVisibility(kTRUE);
2962 mountinghole3->SetLineColor(5); // Yellow
2963 mountinghole3->SetLineWidth(1);
2964 mountinghole3->SetFillColor(mountinghole3->GetLineColor());
2965 mountinghole3->SetFillStyle(4090); // 90% transparent
2966
2967 TGeoVolume *wing = new TGeoVolume("SSDWing",wingshape,medSSDcf);
2968 wing->SetVisibility(kTRUE);
2969 wing->SetLineColor(4); // Blue
2970 wing->SetLineWidth(1);
2971 wing->SetFillColor(wing->GetLineColor());
2972 wing->SetFillStyle(4000); // 0% transparent
2973
2974 TGeoVolume *cablehole = new TGeoVolume("SSDCableHole",
2975 cableholeshape,medSSDair);
2976 cablehole->SetVisibility(kTRUE);
2977 cablehole->SetLineColor(5); // Yellow
2978 cablehole->SetLineWidth(1);
2979 cablehole->SetFillColor(cablehole->GetLineColor());
2980 cablehole->SetFillStyle(4090); // 90% transparent
2981
2982 TGeoVolume *winginsert = new TGeoVolume("SSDWingInsert",
2983 winginsertshape,medSSDste);
2984 winginsert->SetVisibility(kTRUE);
2985 winginsert->SetLineColor(2); // Red
2986 winginsert->SetLineWidth(1);
2987 winginsert->SetFillColor(winginsert->GetLineColor());
2988 winginsert->SetFillStyle(4050); // 50% transparent
2989
2990 TGeoVolume *bracket = new TGeoVolume("SSDMountingBracket",
2991 bracketshape,medSSDal);
2992 bracket->SetVisibility(kTRUE);
2993 bracket->SetLineColor(6); // Purple
2994 bracket->SetLineWidth(1);
2995 bracket->SetFillColor(bracket->GetLineColor());
2996 bracket->SetFillStyle(4000); // 0% transparent
2997
2998 // Mount up a cone
2999 for (Int_t i=0; i<(Int_t)(360./kMountingHolePhi); i++) {
3000 Double_t phiH = i*kMountingHolePhi + 0.5*kMountingHolePhi;
3001 cfconefoam2->AddNode(mountinghole,i+1, new TGeoRotation("", phiH, 0, 0));
3002 }
3003
a30e33f0 3004 for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
3005 Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
3006 cfconeinsert->AddNodeOverlap(coolinghole,i+1, new TGeoRotation("", phiH, 0, 0));
3007 }
3008
3a299c65 3009 cfconeinsert->AddNode(cfconefoam1,1,0);
3010 cfconeinsert->AddNode(cfconefoam2,1,0);
3011
3012 cfcone->AddNode(cfconeinsert,1,0);
3013
3014 for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
3015 Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
a30e33f0 3016 cfcone->AddNode(coolinghole2,i+1, new TGeoRotation("", phiH, 0, 0));
3017 cfcone->AddNode(coolinghole3,i+1, new TGeoRotation("", phiH, 0, 0));
3a299c65 3018 cfcone->AddNodeOverlap(cablehole,i+1, new TGeoRotation("", phiH, 0, 0));
3019 }
3020
3021 for (Int_t i=0; i<(Int_t)(360./kMountingHolePhi); i++) {
3022 Double_t phiH = i*kMountingHolePhi + 0.5*kMountingHolePhi;
3023 cfcone->AddNode(mountinghole2,i+1, new TGeoRotation("", phiH, 0, 0));
3024 cfcone->AddNode(mountinghole3,i+1, new TGeoRotation("", phiH, 0, 0));
3025 }
3026
3027 wing->AddNode(winginsert,1,0);
3028
3029 // Add all volumes in the Cone assembly
3030 vC->AddNode(cfcone,1,new TGeoTranslation(0,0,-kConeZPosition));
3031
3032 for (Int_t i=0; i<4; i++) {
85234543 3033 Double_t thetaW = kThetaWing + 90.*i + angleWideWing/2.;
3034 vC->AddNode(wing, i+1, new TGeoCombiTrans(0, 0, -kConeZPosition+kWingHalfThick,
3a299c65 3035 new TGeoRotation("",thetaW,180,0)));
3036 }
3037
3038 Double_t zBracket = kConeZPosition - coneshape->GetZ(9) +
a30e33f0 3039 2*bracketshape->GetDz();
3a299c65 3040 for (Int_t i=0; i<3; i++) {
3041 Double_t thetaB = 60 + 120.*i;
3042 vC->AddNode(bracket, i+1, new TGeoCombiTrans(0, 0, -zBracket,
3043 new TGeoRotation("",thetaB,0,0)));
3044 }
3045
3046 // Finally put everything in the mother volume
3047 moth->AddNode(cfcylinder,1,0);
3048
3049 moth->AddNode(vC, 1, 0 );
3050 moth->AddNode(vC, 2, new TGeoRotation("",180, 180, 0) );
3051
3052 // Some debugging if requested
3053 if(GetDebug(1)){
3054 vC->PrintNodes();
3055 vC->InspectShape();
3056 }
3057
3058 return;
172b0d90 3059}
3060
3061//______________________________________________________________________
543b7370 3062void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *moth,
3063 TGeoManager *mgr){
798b4e0c 3064//
3065// Creates the cable trays which are outside the ITS support cones
3066// but still inside the TPC
3067// This is now a stearing routine, the actual work is done by three
3068// specialized methods to avoid a really huge unique method
3069//
3070// Input:
3071// moth : the TGeoVolume owing the volume structure
3072// mgr : the GeoManager (default gGeoManager)
3073// Output:
3074//
3075// Created: 15 Nov 2009 Mario Sitta
3076//
3077
3078 TraySupportsSideA(moth, mgr);
3079
3080 ServicesCableSupportSPD(moth, mgr);
3081 ServicesCableSupportSDD(moth, mgr);
3082 ServicesCableSupportSSD(moth, mgr);
3083
3084 return;
3085}
3086
3087//______________________________________________________________________
3088void AliITSv11GeometrySupport::TraySupportsSideA(TGeoVolume *moth,
43aefea7 3089 const TGeoManager *mgr){
798b4e0c 3090//
3091// Creates the structure supporting the ITS cable trays on Side A
3092//
3093// Input:
3094// moth : the TGeoVolume owing the volume structure
3095// mgr : the GeoManager (default gGeoManager)
3096// Output:
3097//
3098// Created: 14 Dec 2009 Mario Sitta
3099// Updated: 26 Feb 2010 Mario Sitta
3100//
3101// Technical data are taken from AutoCAD drawings, L.Simonetti technical
3102// drawings and other (oral) information given by F.Tosello
3103//
3104
3105 // Dimensions and positions of the A-Side Cable Tray Support Ring
3106 // (0872/G/A/01)
3107 const Double_t kSuppRingYTrans = 110.00 *fgkmm;
3108 const Double_t kSuppRingZTrans =(1011.00+435.00) *fgkmm;
3109 const Double_t kSuppForwYTrans = 185.00 *fgkmm;
3110
3111 const Double_t kExtSuppRingSpace1 = 33.00 *fgkmm;
3112 const Double_t kExtSuppRingSpace2 = 45.00 *fgkmm;
3113 const Double_t kExtSuppRingSpcAbov = 30.00 *fgkmm;
3114 const Double_t kExtSuppRingBase = 491.50 *fgkmm;
3115 const Double_t kExtSuppRingInward = 35.00 *fgkmm;
3116 const Double_t kExtSuppRingRmax = 540.00 *fgkmm;
3117 const Double_t kExtSuppRingRint1 = 465.00 *fgkmm;
3118 const Double_t kExtSuppRingRint2 = 467.00 *fgkmm;
3119 const Double_t kExtSuppRingInnerHi = 450.00 *fgkmm;
3120 const Double_t kExtSuppRingInWide = 100.00 *fgkmm;
3121 const Double_t kExtSuppRingR7 = 7.00 *fgkmm;
3122 const Double_t kExtSuppRingR5 = 5.00 *fgkmm;
3123 const Double_t kExtSuppRingThick = 20.00 *fgkmm;
3124
3125 const Double_t kExtSuppRingSpcAng = 10.50 *TMath::DegToRad();
3126 const Double_t kExtSuppRingPartPhi = 15.00 *TMath::DegToRad();
3127 const Double_t kExtSuppRingIntAng = 7.00 *TMath::DegToRad();
3128 const Double_t kExtSuppRingBaseAng = 75.00 *TMath::DegToRad();
3129 const Double_t kExtSuppRingR7Ang = 100.00 *TMath::DegToRad(); // Guessed
3130
3131 const Int_t kExtSuppRingNPtsArc = 10; // N.points to approximate arc
3132
3133 const Double_t kIntSuppRingThick1 = 15.00 *fgkmm;
3134 const Double_t kIntSuppRingThick2 = 13.00 *fgkmm;
3135 const Double_t kIntSuppRingInward = 24.00 *fgkmm;
3136 const Double_t kIntSuppRingThick = 20.00 *fgkmm;
3137
3138 const Double_t kSuppCylHeight = 340.00 *fgkmm;
3139 const Double_t kSuppCylRint = 475.00 *fgkmm;
3140 const Double_t kSuppCylRext = 478.00 *fgkmm;
3141 const Double_t kSuppCylDispl = 137.70 *fgkmm;
3142
3143 const Double_t kSuppSpacerHeight = 30.00 *fgkmm;
3144 const Double_t kSuppSpacerThick = 10.00 *fgkmm;
3145
3146 const Double_t kSuppSpacerAngle = 15.00; // Degrees
3147
3148 const Double_t kSuppForwRingRint1 = 500.00 *fgkmm;
3149 const Double_t kSuppForwRingRint2 = 540.00 *fgkmm;
3150 const Double_t kSuppForwRingRext = 560.00 *fgkmm;
3151 const Double_t kSuppForwRingThikAll = 50.00 *fgkmm;
3152 const Double_t kSuppForwRingThikInt = 20.00 *fgkmm;
3153
3154 // (0872/G/B/01)
3155 const Double_t kSuppForwConeRmin = 558.00 *fgkmm;
3156 const Double_t kSuppForwConeRmax = 681.00 *fgkmm;
3157 const Double_t kSuppForwConeLen1 = 318.00 *fgkmm;
3158 const Double_t kSuppForwConeLen2 = 662.00 *fgkmm;
3159 const Double_t kSuppForwConeThick = 3.00 *fgkmm;
3160
3161 const Double_t kSuppBackRingPlacTop = 90.00 *fgkmm;
3162 const Double_t kSuppBackRingPlacSid = 50.00 *fgkmm;
3163 const Double_t kSuppBackRingHeight = 760.00 *fgkmm;
3164 const Double_t kSuppBackRingRext = 760.00 *fgkmm;
3165 const Double_t kSuppBackRingRint = 685.00 *fgkmm;
3166// const Double_t kSuppBackRingRint2 = 675.00 *fgkmm;
3167 const Double_t kSuppBackRingR10 = 10.00 *fgkmm;
3168 const Double_t kSuppBackRingBase = 739.00 *fgkmm;
3169 const Double_t kSuppBackRingThikAll = 50.00 *fgkmm;
3170 const Double_t kSuppBackRingThick1 = 20.00 *fgkmm;
3171 const Double_t kSuppBackRingThick2 = 20.00 *fgkmm;
3172
3173// const Double_t kSuppBackRingPlacAng = 10.00 *TMath::DegToRad();
3174 const Double_t kSuppBackRingPlacAng = 10.25 *TMath::DegToRad();//Fix ovlp.
3175 const Double_t kSuppBackRing2ndAng1 = 78.40 *TMath::DegToRad();
3176 const Double_t kSuppBackRing2ndAng2 = 45.00 *TMath::DegToRad();
3177
3178 const Int_t kSuppBackRingNPtsArc = 10; // N.points to approximate arc
3179
3180 // (0872/G/C/01)
3181 const Double_t kRearSuppZTransGlob =(1011.00+9315.00-6040.00) *fgkmm;
3182 const Double_t kBackRodZTrans = 2420.00 *fgkmm;
3183
3184 const Double_t kBackRodLength = 1160.00 *fgkmm;
3185 const Double_t kBackRodThickLen = 20.00 *fgkmm;
3186 const Double_t kBackRodDiameter = 20.00 *fgkmm;
3187
3188 const Double_t kSuppRearRingRint = 360.00 *fgkmm;
3189 const Double_t kSuppRearRingRext1 = 410.00 *fgkmm;
3190 const Double_t kSuppRearRingRext2 = 414.00 *fgkmm;
3191 const Double_t kSuppRearRingHeight = 397.00 *fgkmm;
3192 const Double_t kSuppRearRingTopWide = 111.87 *fgkmm;
3193 const Double_t kSuppRearRingBase = 451.50 *fgkmm;
3194 const Double_t kSuppRearRingBaseHi = 58.00 *fgkmm;
3195 const Double_t kSuppRearRingSideHi = 52.00 *fgkmm;
3196 const Double_t kSuppRearRingInside = 40.00 *fgkmm;
3197 const Double_t kSuppRearRingInsideHi= 12.00 *fgkmm;
3198 const Double_t kSuppRearRingThick = 20.00 *fgkmm;
3199 const Double_t kSuppRearRingXRodHole= 441.50 *fgkmm;
3200 const Double_t kSuppRearRingYRodHole= 42.00 *fgkmm;
3201
3202 const Double_t kSuppRearRing1stAng = 22.00 *TMath::DegToRad();
3203 const Double_t kSuppRearRingStepAng = 15.00 *TMath::DegToRad();
3204
3205 const Int_t kSuppRearRingNPtsArc = 10; // N.points to approximate arc
3206
3207
3208 // Local variables
3209 Double_t xprof[2*(15+kExtSuppRingNPtsArc)],yprof[2*(15+kExtSuppRingNPtsArc)];
3210 Double_t slp1, slp2, phi, xm, ym;
3211 Double_t xloc, yloc, zloc, rmin, rmax, deltaR;
3212 Int_t npoints;
3213
3214
3215 // The whole support as an assembly
3216 TGeoVolumeAssembly *trayASuppStruct = new TGeoVolumeAssembly("ITSsuppSideAStructure");
3217
3218
3219 // First create all needed shapes
3220
3221 // The External Ring (part of 0872/G/A/01): a really complex Xtru
3222 TGeoXtru *extSuppRing = new TGeoXtru(2);
3223
3224 // First the upper notch...
3225 xprof[ 0] = kExtSuppRingSpace1;
3226 yprof[ 0] = kExtSuppRingInnerHi + kExtSuppRingSpcAbov;
3227
3228 slp1 = TMath::Tan(TMath::Pi()/2 - kExtSuppRingSpcAng);
3229 IntersectCircle(slp1, xprof[0], yprof[0], kExtSuppRingRmax, 0., 0.,
3230 xprof[5], yprof[5], xm, ym); // Ignore dummy xm,ym
3231
3232 xprof[ 4] = xprof[5];
3233 yprof[ 4] = yprof[5] - kExtSuppRingR5/TMath::Tan(kExtSuppRingSpcAng);
3234 xprof[ 3] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/6));
3235 yprof[ 3] = yprof[4] - kExtSuppRingR5*( TMath::Sin(TMath::Pi()/6));
3236 xprof[ 2] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/3));
3237 yprof[ 2] = yprof[4] - kExtSuppRingR5*( TMath::Sin(TMath::Pi()/3));
3238 xprof[ 1] = xprof[4] - kExtSuppRingR5;
3239 yprof[ 1] = yprof[4] - kExtSuppRingR5;
3240
3241 Int_t indx = 5+kExtSuppRingNPtsArc;
3242 // ...then the external arc, approximated with segments,...
3243 xprof[indx] = kExtSuppRingBase;
3244 yprof[indx] = TMath::Sqrt(kExtSuppRingRmax*kExtSuppRingRmax -
3245 kExtSuppRingBase*kExtSuppRingBase);
3246 Double_t alphamin = TMath::ASin(kExtSuppRingSpace2/kExtSuppRingRmax);
3247 Double_t alphamax = TMath::Pi()/2 -
3248 TMath::ASin(yprof[5+kExtSuppRingNPtsArc]/kExtSuppRingRmax);
3249
3250 for (Int_t jp = 1; jp < kExtSuppRingNPtsArc; jp++) {
3251 Double_t alpha = jp*(alphamax-alphamin)/kExtSuppRingNPtsArc;
3252 xprof[5+jp] = kExtSuppRingRmax*TMath::Sin(alpha);
3253 yprof[5+jp] = kExtSuppRingRmax*TMath::Cos(alpha);
3254 }
3255 // ...and finally the interior profile
3256 xprof[indx+1] = kExtSuppRingBase;
3257 yprof[indx+1] = kSuppRingYTrans;
3258 xprof[indx+2] = xprof[indx+1] - kExtSuppRingInward;
3259 yprof[indx+2] = yprof[indx+1];
3260
3261 phi = TMath::Pi()/2 - 4*kExtSuppRingPartPhi - kExtSuppRingIntAng;
3262 slp1 = TMath::Tan(TMath::Pi() - kExtSuppRingBaseAng);
3263 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3264 xm = kExtSuppRingRint2*TMath::Cos(phi);
3265 ym = kExtSuppRingRint2*TMath::Sin(phi);
3266 IntersectLines(slp1, xprof[indx+2], yprof[indx+2], slp2, xm, ym,
3267 xprof[indx+3], yprof[indx+3]);
3268
3269 slp1 = slp2;
3270 phi += kExtSuppRingPartPhi;
3271 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3272 xm = kExtSuppRingRint1*TMath::Cos(phi);
3273 ym = kExtSuppRingRint1*TMath::Sin(phi);
3274 IntersectLines(slp1, xprof[indx+3], yprof[indx+3], slp2, xm, ym,
3275 xprof[indx+4], yprof[indx+4]);
3276
3277 slp1 = slp2;
3278 phi += kExtSuppRingPartPhi;
3279 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3280 xm = kExtSuppRingRint2*TMath::Cos(phi);
3281 ym = kExtSuppRingRint2*TMath::Sin(phi);
3282 IntersectLines(slp1, xprof[indx+4], yprof[indx+4], slp2, xm, ym,
3283 xprof[indx+5], yprof[indx+5]);
3284
3285 slp1 = slp2;
3286 phi += kExtSuppRingPartPhi;
3287 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3288 xm = kExtSuppRingRint1*TMath::Cos(phi);
3289 ym = kExtSuppRingRint1*TMath::Sin(phi);
3290 IntersectLines(slp1, xprof[indx+5], yprof[indx+5], slp2, xm, ym,
3291 xprof[indx+6], yprof[indx+6]);
3292
3293 xprof[indx+9] = kExtSuppRingInWide;
3294 yprof[indx+9] = kExtSuppRingInnerHi;
3295 xprof[indx+8] = xprof[indx+9] +
3296 (1 - TMath::Cos(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
3297 yprof[indx+8] = yprof[indx+9] +
3298 ( TMath::Sin(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
3299 xprof[indx+7] = xprof[indx+9] +
3300 (1 + TMath::Cos(kExtSuppRingR7Ang ))*kExtSuppRingR7;
3301 yprof[indx+7] = yprof[indx+9] +
3302 ( TMath::Sin(kExtSuppRingR7Ang ))*kExtSuppRingR7;
3303 // Gosh, we did the right side! now reflex on the left side
3304 npoints = (sizeof(xprof)/sizeof(Double_t))/2;
3305 for (Int_t jp = 0; jp < npoints; jp++) {
3306 xprof[npoints+jp] = -xprof[npoints-1-jp];
3307 yprof[npoints+jp] = yprof[npoints-1-jp];
3308 }
3309 // wow! now the actual Xtru
3310 extSuppRing->DefinePolygon(2*npoints, xprof, yprof);
3311 extSuppRing->DefineSection(0,0);
3312 extSuppRing->DefineSection(1,kExtSuppRingThick);
3313
3314 // The Internal Ring (part of 0872/G/A/01): another complex Xtru
3315 TGeoXtru *intSuppRing = new TGeoXtru(2);
3316
3317 // First the external profile...
3318 npoints = 0;
3319
3320 slp1 = 0;
3321 phi = TMath::Pi()/2 - kExtSuppRingPartPhi - kExtSuppRingIntAng;
3322 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3323 xm = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
3324 ym = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
3325 IntersectLines(slp1, 0, kExtSuppRingInnerHi+kExtSuppRingSpcAbov,
3326 slp2, xm, ym,
3327 xprof[npoints], yprof[npoints]);
3328 npoints++;
3329
3330 slp1 = slp2;
3331 phi -= kExtSuppRingPartPhi;
3332 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3333 xm = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
3334 ym = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
3335 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3336 slp2, xm, ym,
3337 xprof[npoints], yprof[npoints]);
3338 npoints++;
3339
3340 slp1 = slp2;
3341 phi -= kExtSuppRingPartPhi;
3342 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3343 xm = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
3344 ym = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
3345 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3346 slp2, xm, ym,
3347 xprof[npoints], yprof[npoints]);
3348 npoints++;
3349
3350 slp1 = slp2;
3351 phi -= kExtSuppRingPartPhi;
3352 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3353 xm = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
3354 ym = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
3355 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3356 slp2, xm, ym,
3357 xprof[npoints], yprof[npoints]);
3358 npoints++;
3359
3360 xprof[npoints] = kExtSuppRingBase-kIntSuppRingInward;
3361 yprof[npoints] = Yfrom2Points(xprof[npoints-1], yprof[npoints-1], xm, ym,
3362 xprof[npoints]);
3363 npoints++;
3364
3365 xprof[npoints] = xprof[npoints-1];
3366 yprof[npoints] = kSuppRingYTrans;
3367 npoints++;
3368 // ...and then the interior profile, which is identical to extSuppRing one
3369 for (Int_t jp=0; jp < 8; jp++) {
3370 xprof[npoints] = extSuppRing->GetX(17+jp);
3371 yprof[npoints] = extSuppRing->GetY(17+jp);
3372 npoints++;
3373 }
3374 // We did the right side! now reflex on the left side
3375 for (Int_t jp = 0; jp < npoints; jp++) {
3376 xprof[npoints+jp] = -xprof[npoints-1-jp];
3377 yprof[npoints+jp] = yprof[npoints-1-jp];
3378 }
3379 // And now the actual Xtru
3380 intSuppRing->DefinePolygon(2*npoints, xprof, yprof);
3381 intSuppRing->DefineSection(0,0);
3382 intSuppRing->DefineSection(1,kIntSuppRingThick);
3383
3384 // The intermediate cylinder (0872/G/A/03): a TubeSeg
3385 alphamin = TMath::ASin(kSuppCylDispl/kSuppCylRint)*TMath::RadToDeg();
3386 alphamax = 180 - alphamin;
3387 TGeoTubeSeg *interCylind = new TGeoTubeSeg(kSuppCylRint, kSuppCylRext,
3388 kSuppCylHeight/2, alphamin, alphamax);
3389
3390 // The spacer (0872/G/A/03): a simple Xtru
3391 TGeoXtru *suppSpacer = new TGeoXtru(2);
3392
3393 xprof[0] = kSuppSpacerHeight;
3394 yprof[0] = kSuppSpacerThick;
3395 xprof[1] = xprof[0];
3396 yprof[1] = 0;
3397 xprof[2] = 0;
3398 yprof[2] = 0;
3399 xprof[3] = kSuppSpacerThick*SinD(kSuppSpacerAngle);
3400 yprof[3] = yprof[0];
3401
3402 suppSpacer->DefinePolygon(4, xprof, yprof);
3403 suppSpacer->DefineSection(0,-kSuppCylHeight/2);
3404 suppSpacer->DefineSection(1, kSuppCylHeight/2);
3405
3406 // The forward ring (0872/G/B/02): a Pcon (slight oversimplification)
3407 Double_t rmean = (kSuppForwRingRint1+kSuppForwRingRext)/2;
3408 alphamin = TMath::ASin(kSuppForwYTrans/rmean)*TMath::RadToDeg();
3409 alphamax = 180 - alphamin;
3410
3411 TGeoPcon *forwardRing = new TGeoPcon(alphamin,alphamax-alphamin,4);
3412
3413 forwardRing->DefineSection(0,0,
3414 kSuppForwRingRint1,kSuppForwRingRext);
3415 forwardRing->DefineSection(1,kSuppForwRingThikInt,
3416 kSuppForwRingRint1,kSuppForwRingRext);
3417 forwardRing->DefineSection(2,kSuppForwRingThikInt,
3418 kSuppForwRingRint2,kSuppForwRingRext);
3419 forwardRing->DefineSection(3,kSuppForwRingThikAll,
3420 kSuppForwRingRint2,kSuppForwRingRext);
3421
3422 // The forward cone (0872/G/B/03): a TGeoPcon
3423 TGeoPcon *forwardCone = new TGeoPcon(alphamin,alphamax-alphamin,3);
3424
3425 forwardCone->DefineSection(0,0,
3426 kSuppForwConeRmin-kSuppForwConeThick,
3427 kSuppForwConeRmin);
3428 forwardCone->DefineSection(1,kSuppForwConeLen1,
3429 kSuppForwConeRmin-kSuppForwConeThick,
3430 kSuppForwConeRmin);
3431 forwardCone->DefineSection(2,kSuppForwConeLen1+kSuppForwConeLen2,
3432 kSuppForwConeRmax-kSuppForwConeThick,
3433 kSuppForwConeRmax);
3434
3435 // The first part of the Back Ring (part of 0872/G/B/01): a complex Xtru
3436 TGeoXtru *firstSuppBackRing = new TGeoXtru(2);
3437
3438 // First the external profile... (the arc is approximated with segments)
3439 npoints = 0;
3440
3441 xprof[npoints] = kSuppBackRingPlacTop;
3442 yprof[npoints] = kSuppBackRingHeight;
3443 npoints++;
3444
3445 alphamax = TMath::Pi()/2 - TMath::ASin(kSuppBackRingPlacTop/kSuppBackRingRext);
3446 alphamin = TMath::ASin((kSuppForwYTrans+kSuppBackRingPlacSid)/kSuppBackRingRext);
3447
3448 xprof[npoints] = xprof[npoints-1];
3449 yprof[npoints] = kSuppBackRingRext*TMath::Sin(alphamax);
3450 npoints++;
3451
3452 for (Int_t jp = 1; jp <= kSuppBackRingNPtsArc; jp++) {
3453 Double_t alpha = alphamax - jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
3454 xprof[npoints] = kSuppBackRingRext*TMath::Cos(alpha);
3455 yprof[npoints] = kSuppBackRingRext*TMath::Sin(alpha);
3456 npoints++;
3457 }
3458
3459 xprof[npoints] = kSuppBackRingBase -
3460 kSuppBackRingPlacSid*TMath::Tan(kSuppBackRingPlacAng);
3461 yprof[npoints] = yprof[npoints-1];
3462 npoints++;
3463
3464 xprof[npoints] = kSuppBackRingBase;
3465 yprof[npoints] = kSuppForwYTrans;
3466 npoints++;
3467 // ...then the internal profile (the arc is approximated with segments)
3468 alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint);
3469 alphamax = TMath::Pi()/2;
3470
3471 for (Int_t jp = 0; jp < kSuppBackRingNPtsArc; jp++) {
3472 Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
3473 xprof[npoints] = kSuppBackRingRint*TMath::Cos(alpha);
3474 yprof[npoints] = kSuppBackRingRint*TMath::Sin(alpha);
3475 npoints++;
3476 }
3477
3478 xprof[npoints] = 0;
3479 yprof[npoints] = kSuppBackRingRint;
3480 npoints++;
3481 // We did the right side! now reflex on the left side (except last point)
3482 for (Int_t jp = 0; jp < npoints-1; jp++) {
3483 xprof[npoints+jp] = -xprof[npoints-jp-2];
3484 yprof[npoints+jp] = yprof[npoints-jp-2];
3485 }
3486 // And now the actual Xtru
3487 firstSuppBackRing->DefinePolygon(2*npoints-1, xprof, yprof);
3488 firstSuppBackRing->DefineSection(0,0);
3489 firstSuppBackRing->DefineSection(1,kSuppBackRingThick1);
3490
3491 // The second part of the Back Ring (part of 0872/G/B/01): a Pcon
3492 // (slight oversimplification)
3493 alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint)*TMath::RadToDeg();
3494 alphamax = 180 - alphamin;
3495
3496 TGeoPcon *secondSuppBackRing = new TGeoPcon(alphamin,alphamax-alphamin,6);
3497
3498 deltaR = kSuppBackRingThick2/TMath::Sin(kSuppBackRing2ndAng1);
3499 rmin = kSuppBackRingRint - kSuppBackRingThick1/TMath::Tan(kSuppBackRing2ndAng1);
3500 rmax = rmin + deltaR + kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
3501 secondSuppBackRing->DefineSection(0, 0, rmin, rmax);
3502
3503 zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1/3));
3504 rmax -= kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1/3);
3505 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
3506 secondSuppBackRing->DefineSection(1, zloc, rmin, rmax);
3507
3508 zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1*2/3));
3509 rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1*2/3);
3510 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
3511 secondSuppBackRing->DefineSection(2, zloc, rmin, rmax);
3512
3513 zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1));
3514 rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
3515 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
3516 secondSuppBackRing->DefineSection(3, zloc, rmin, rmax);
3517
3518 slp1 = TMath::Tan(kSuppBackRing2ndAng2);
3519 slp2 = TMath::Tan(TMath::Pi()/2 + kSuppBackRing2ndAng1);
3520 IntersectLines(-slp1,kSuppBackRingThikAll,deltaR/2,
3521 slp2,kSuppBackRingThikAll,deltaR,
3522 xm, ym);
3523
3524 zloc = xm - kSuppBackRingThick1;
3525 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
3526 rmax = rmin + deltaR;
3527 secondSuppBackRing->DefineSection(4, zloc, rmin, rmax);
3528
3529 zloc = kSuppBackRingThikAll - kSuppBackRingThick1;
3530 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
3531 rmax = rmin + deltaR/2;
3532 secondSuppBackRing->DefineSection(5, zloc, rmin, rmax);
3533
3534 // The supporting rod: a Tube
3535 TGeoTube *suppRod = new TGeoTube(0, kBackRodDiameter/2,
3536 (kBackRodLength - kBackRodThickLen)/2);
3537
3538 // The Back Ring (0872/G/C/01): another complex Xtru
3539 TGeoXtru *suppRearRing = new TGeoXtru(2);
3540
3541 // First the external profile...
3542 npoints = 0;
3543
3544 xprof[npoints] = kSuppRearRingTopWide;
3545 yprof[npoints] = kSuppRearRingHeight;
3546 npoints++;
3547
3548 phi = kSuppRearRing1stAng;
3549 slp1 = TMath::Tan(TMath::Pi() - phi);
3550 phi += kSuppRearRingStepAng;
3551 slp2 = TMath::Tan(TMath::Pi() - phi);
3552 xm = kSuppRearRingRext2*TMath::Sin(phi);
3553 ym = kSuppRearRingRext2*TMath::Cos(phi);
3554 IntersectLines(slp1, kSuppRearRingTopWide, kSuppRearRingHeight,
3555 slp2, xm, ym,
3556 xprof[npoints], yprof[npoints]);
3557 npoints++;
3558
3559 slp1 = slp2;
3560 phi += kSuppRearRingStepAng;
3561 slp2 = TMath::Tan(TMath::Pi() - phi);
3562 xm = kSuppRearRingRext1*TMath::Sin(phi);
3563 ym = kSuppRearRingRext1*TMath::Cos(phi);
3564 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3565 slp2, xm, ym,
3566 xprof[npoints], yprof[npoints]);
3567 npoints++;
3568
3569 slp1 = slp2;
3570 phi += kSuppRearRingStepAng;
3571 slp2 = TMath::Tan(TMath::Pi() - phi);
3572 xm = kSuppRearRingRext2*TMath::Sin(phi);
3573 ym = kSuppRearRingRext2*TMath::Cos(phi);
3574 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3575 slp2, xm, ym,
3576 xprof[npoints], yprof[npoints]);
3577 npoints++;
3578
3579 slp1 = slp2;
3580 slp2 = 0;
3581 xm = kSuppRearRingBase;
3582 ym = kSuppRearRingBaseHi + kSuppRearRingSideHi;
3583 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3584 slp2, xm, ym,
3585 xprof[npoints], yprof[npoints]);
3586 npoints++;
3587
3588 xprof[npoints] = kSuppRearRingBase;
3589 yprof[npoints] = kSuppRearRingBaseHi + kSuppRearRingSideHi;
3590 npoints++;
3591 xprof[npoints] = xprof[npoints - 1];
3592 yprof[npoints] = kSuppRearRingBaseHi;
3593 npoints++;
3594 xprof[npoints] = xprof[npoints - 1] - kSuppRearRingInside;
3595 yprof[npoints] = yprof[npoints - 1];
3596 npoints++;
3597 xprof[npoints] = xprof[npoints - 1];
3598 yprof[npoints] = yprof[npoints - 1] + kSuppRearRingInsideHi;
3599 npoints++;
3600 // ...then the internal arc, approximated with segments,...
3601 xprof[npoints] = kSuppRearRingRint;
3602 yprof[npoints] = yprof[npoints - 1];
3603
3604 alphamin = TMath::ASin(kSuppRearRingBaseHi/kSuppRearRingRint);
3605 alphamax = TMath::Pi()/2;
3606
3607 for (Int_t jp = 1; jp < kSuppRearRingNPtsArc; jp++) {
3608 Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppRearRingNPtsArc;
3609 xprof[npoints+jp] = kSuppRearRingRint*TMath::Cos(alpha);
3610 yprof[npoints+jp] = kSuppRearRingRint*TMath::Sin(alpha);
3611 }
3612
3613 xprof[npoints+kSuppRearRingNPtsArc] = 0;
3614 yprof[npoints+kSuppRearRingNPtsArc] = kSuppRearRingRint;
3615 // We did the right side! now reflex on the left side
3616 Int_t nTotalPoints = npoints+kSuppRearRingNPtsArc;
3617 for (Int_t jp = 0; jp < nTotalPoints; jp++) {
3618 xprof[nTotalPoints+1+jp] = -xprof[nTotalPoints-1-jp];
3619 yprof[nTotalPoints+1+jp] = yprof[nTotalPoints-1-jp];
3620 }
3621
3622 // And now the actual Xtru
3623 suppRearRing->DefinePolygon(2*nTotalPoints+1, xprof, yprof);
3624 suppRearRing->DefineSection(0,0);
3625 suppRearRing->DefineSection(1,kSuppRearRingThick);
3626
3627
3628 // We have all shapes: now create the real volumes
3629 TGeoMedium *medAl = mgr->GetMedium("ITS_ANTICORODAL$");
3630
3631 TGeoVolume *sideAExtSuppRing = new TGeoVolume("ITSsuppSideAExtSuppRing",
3632 extSuppRing, medAl);
3633
3634 sideAExtSuppRing->SetVisibility(kTRUE);
3635 sideAExtSuppRing->SetLineColor(kMagenta+1);
3636 sideAExtSuppRing->SetLineWidth(1);
3637 sideAExtSuppRing->SetFillColor(sideAExtSuppRing->GetLineColor());
3638 sideAExtSuppRing->SetFillStyle(4000); // 0% transparent
3639
3640 TGeoVolume *sideAIntSuppRing = new TGeoVolume("ITSsuppSideAIntSuppRing",
3641 intSuppRing, medAl);
3642
3643 sideAIntSuppRing->SetVisibility(kTRUE);
3644 sideAIntSuppRing->SetLineColor(kMagenta+1);
3645 sideAIntSuppRing->SetLineWidth(1);
3646 sideAIntSuppRing->SetFillColor(sideAIntSuppRing->GetLineColor());
3647 sideAIntSuppRing->SetFillStyle(4000); // 0% transparent
3648
3649 TGeoVolume *sideASuppCyl = new TGeoVolume("ITSsuppSideASuppCyl",
3650 interCylind, medAl);
3651
3652 sideASuppCyl->SetVisibility(kTRUE);
3653 sideASuppCyl->SetLineColor(kMagenta+1);
3654 sideASuppCyl->SetLineWidth(1);
3655 sideASuppCyl->SetFillColor(sideASuppCyl->GetLineColor());
3656 sideASuppCyl->SetFillStyle(4000); // 0% transparent
3657
3658 TGeoVolume *sideASuppSpacer = new TGeoVolume("ITSsuppSideASuppSpacer",
3659 suppSpacer, medAl);
3660
3661 sideASuppSpacer->SetVisibility(kTRUE);
3662 sideASuppSpacer->SetLineColor(kMagenta+1);
3663 sideASuppSpacer->SetLineWidth(1);
3664 sideASuppSpacer->SetFillColor(sideASuppSpacer->GetLineColor());
3665 sideASuppSpacer->SetFillStyle(4000); // 0% transparent
3666
3667 TGeoVolume *sideASuppForwRing = new TGeoVolume("ITSsuppSideASuppForwRing",
3668 forwardRing, medAl);
3669
3670 sideASuppForwRing->SetVisibility(kTRUE);
3671 sideASuppForwRing->SetLineColor(kMagenta+1);
3672 sideASuppForwRing->SetLineWidth(1);
3673 sideASuppForwRing->SetFillColor(sideASuppForwRing->GetLineColor());
3674 sideASuppForwRing->SetFillStyle(4000); // 0% transparent
3675
3676 TGeoVolume *sideASuppForwCone = new TGeoVolume("ITSsuppSideASuppForwCone",
3677 forwardCone, medAl);
3678
3679 sideASuppForwCone->SetVisibility(kTRUE);
3680 sideASuppForwCone->SetLineColor(kMagenta+1);
3681 sideASuppForwCone->SetLineWidth(1);
3682 sideASuppForwCone->SetFillColor(sideASuppForwCone->GetLineColor());
3683 sideASuppForwCone->SetFillStyle(4000); // 0% transparent
3684
3685 TGeoVolume *sideAFirstSuppBackRing = new TGeoVolume("ITSsuppSideAFirstSuppBackRing",
3686 firstSuppBackRing, medAl);
3687
3688 sideAFirstSuppBackRing->SetVisibility(kTRUE);
3689 sideAFirstSuppBackRing->SetLineColor(kMagenta+1);
3690 sideAFirstSuppBackRing->SetLineWidth(1);
3691 sideAFirstSuppBackRing->SetFillColor(sideAFirstSuppBackRing->GetLineColor());
3692 sideAFirstSuppBackRing->SetFillStyle(4000); // 0% transparent
3693
3694 TGeoVolume *sideASecondSuppBackRing = new TGeoVolume("ITSsuppSideASecondSuppBackRing",
3695 secondSuppBackRing, medAl);
3696
3697 sideASecondSuppBackRing->SetVisibility(kTRUE);
3698 sideASecondSuppBackRing->SetLineColor(kMagenta+1);
3699 sideASecondSuppBackRing->SetLineWidth(1);
3700 sideASecondSuppBackRing->SetFillColor(sideASecondSuppBackRing->GetLineColor());
3701 sideASecondSuppBackRing->SetFillStyle(4000); // 0% transparent
3702
3703 TGeoVolume *sideASuppRod = new TGeoVolume("ITSsuppSideASuppRod",
3704 suppRod, medAl);
3705
3706 sideASuppRod->SetVisibility(kTRUE);
3707 sideASuppRod->SetLineColor(kMagenta+1);
3708 sideASuppRod->SetLineWidth(1);
3709 sideASuppRod->SetFillColor(sideASuppRod->GetLineColor());
3710 sideASuppRod->SetFillStyle(4000); // 0% transparent
3711
3712 TGeoVolume *sideASuppRearRing = new TGeoVolume("ITSsuppSideASuppRearRing",
3713 suppRearRing, medAl);
3714
3715 sideASuppRearRing->SetVisibility(kTRUE);
3716 sideASuppRearRing->SetLineColor(kMagenta+1);
3717 sideASuppRearRing->SetLineWidth(1);
3718 sideASuppRearRing->SetFillColor(sideASuppRearRing->GetLineColor());
3719 sideASuppRearRing->SetFillStyle(4000); // 0% transparent
3720
3721
3722 // Now build up the support structure
3723 zloc = kSuppRingZTrans;
3724 trayASuppStruct->AddNode(sideAExtSuppRing, 1,
3725 new TGeoTranslation(0, 0, zloc) );
3726 trayASuppStruct->AddNode(sideAExtSuppRing, 2,
3727 new TGeoCombiTrans( 0, 0, zloc,
3728 new TGeoRotation("",180,0,0)));
3729
3730 zloc += kExtSuppRingThick;
3731 trayASuppStruct->AddNode(sideAIntSuppRing, 1,
3732 new TGeoTranslation(0, 0, zloc) );
3733 trayASuppStruct->AddNode(sideAIntSuppRing, 2,
3734 new TGeoCombiTrans( 0, 0, zloc,
3735 new TGeoRotation("",180,0,0)));
3736
3737 xloc = kExtSuppRingBase - kIntSuppRingInward;
3738 yloc = kSuppRingYTrans;
3739 zloc += (kIntSuppRingThick + kSuppCylHeight/2);
3740 trayASuppStruct->AddNode(sideASuppCyl, 1,
3741 new TGeoTranslation(0, 0, zloc) );
3742 trayASuppStruct->AddNode(sideASuppCyl, 2,
3743 new TGeoCombiTrans( 0, 0, zloc,
3744 new TGeoRotation("",180,0,0)));
3745 trayASuppStruct->AddNode(sideASuppSpacer, 1,
3746 new TGeoCombiTrans( xloc, yloc, zloc,
3747 new TGeoRotation("",90+kSuppSpacerAngle,0,0)));
3748 trayASuppStruct->AddNode(sideASuppSpacer, 2,
3749 new TGeoCombiTrans(-xloc, yloc, zloc,
3750 new TGeoRotation("",0,180,kSuppSpacerAngle-90)));
3751 trayASuppStruct->AddNode(sideASuppSpacer, 3,
3752 new TGeoCombiTrans( xloc,-yloc, zloc,
3753 new TGeoRotation("",180,180,kSuppSpacerAngle-90)));
3754 trayASuppStruct->AddNode(sideASuppSpacer, 4,
3755 new TGeoCombiTrans(-xloc,-yloc, zloc,
3756 new TGeoRotation("",270+kSuppSpacerAngle,0,0)));
3757
3758
3759 zloc += kSuppCylHeight/2;
3760 trayASuppStruct->AddNode(sideAIntSuppRing, 3,
3761 new TGeoTranslation(0, 0, zloc) );
3762 trayASuppStruct->AddNode(sideAIntSuppRing, 4,
3763 new TGeoCombiTrans( 0, 0, zloc,
3764 new TGeoRotation("",180,0,0)));
3765
3766 zloc += kIntSuppRingThick;
3767 trayASuppStruct->AddNode(sideAExtSuppRing, 3,
3768 new TGeoTranslation(0, 0, zloc) );
3769 trayASuppStruct->AddNode(sideAExtSuppRing, 4,
3770 new TGeoCombiTrans( 0, 0, zloc,
3771 new TGeoRotation("",180,0,0)));
3772
3773 zloc += kExtSuppRingThick;
3774 trayASuppStruct->AddNode(sideASuppForwRing, 1,
3775 new TGeoTranslation(0, 0, zloc) );
3776 trayASuppStruct->AddNode(sideASuppForwRing, 2,
3777 new TGeoCombiTrans( 0, 0, zloc,
3778 new TGeoRotation("",180,0,0)));
3779
3780 zloc += kSuppForwRingThikAll;
3781 trayASuppStruct->AddNode(sideASuppForwCone, 1,
3782 new TGeoTranslation(0, 0, zloc) );
3783 trayASuppStruct->AddNode(sideASuppForwCone, 2,
3784 new TGeoCombiTrans( 0, 0, zloc,
3785 new TGeoRotation("",180,0,0)));
3786
3787 zloc += (kSuppForwConeLen1+kSuppForwConeLen2);
3788 trayASuppStruct->AddNode(sideAFirstSuppBackRing, 1,
3789 new TGeoTranslation(0, 0, zloc) );
3790 trayASuppStruct->AddNode(sideAFirstSuppBackRing, 2,
3791 new TGeoCombiTrans( 0, 0, zloc,
3792 new TGeoRotation("",180,0,0)));
3793
3794 zloc += kSuppBackRingThick1;
3795 trayASuppStruct->AddNode(sideASecondSuppBackRing, 1,
3796 new TGeoTranslation(0, 0, zloc) );
3797 trayASuppStruct->AddNode(sideASecondSuppBackRing, 2,
3798 new TGeoCombiTrans( 0, 0, zloc,
3799 new TGeoRotation("",180,0,0)));
3800
3801 xloc = kSuppRearRingXRodHole;
3802 yloc = kSuppRearRingBaseHi + kSuppRearRingYRodHole;
3803 zloc = kRearSuppZTransGlob - kBackRodZTrans + suppRod->GetDz();
3804 trayASuppStruct->AddNode(sideASuppRod, 1,
3805 new TGeoTranslation( xloc, yloc, zloc) );
3806 trayASuppStruct->AddNode(sideASuppRod, 2,
3807 new TGeoTranslation(-xloc, yloc, zloc) );
3808 trayASuppStruct->AddNode(sideASuppRod, 3,
3809 new TGeoTranslation( xloc,-yloc, zloc) );
3810 trayASuppStruct->AddNode(sideASuppRod, 4,
3811 new TGeoTranslation(-xloc,-yloc, zloc) );
3812
3813 zloc += suppRod->GetDz();
3814 trayASuppStruct->AddNode(sideASuppRearRing, 1,
3815 new TGeoTranslation( 0, 0, zloc) );
3816 trayASuppStruct->AddNode(sideASuppRearRing, 2,
3817 new TGeoCombiTrans( 0, 0, zloc,
3818 new TGeoRotation("",180,0,0)));
3819
3820
3821 // Finally put everything in the mother volume
3822 moth->AddNode(trayASuppStruct,1,0);
3823
3824 return;
3825}
3826
3827//______________________________________________________________________
3828void AliITSv11GeometrySupport::ServicesCableSupportSPD(TGeoVolume *moth,
3829 TGeoManager *mgr){
3830//
3831// Creates the all SPD cable trays which are outside the ITS support cones
3832// but still inside the TPC
3833// In order to avoid a huge monolithic routine, this method actually
3834// calls inner methods to create and assemble the various (macro)pieces
3835//
3836// Input:
3837// moth : the TGeoVolume owing the volume structure
3838// mgr : the GeoManager (default gGeoManager)
3839// Output:
3840//
3841// Created: ??? Bjorn S. Nilsen
3842// Updated: 15 Nov 2009 Mario Sitta
3843//
3844// Technical data are taken from AutoCAD drawings and other (oral)
3845// information given by F.Tosello
3846//
3847
3848 SPDCableTraysSideA(moth, mgr);
aa177c73 3849 SPDCableTraysSideC(moth, mgr);
798b4e0c 3850
3851}
3852
3853//______________________________________________________________________
3854void AliITSv11GeometrySupport::ServicesCableSupportSDD(TGeoVolume *moth,
3855 TGeoManager *mgr){
3856//
3857// Creates the all SDD cable trays which are outside the ITS support cones
3858// but still inside the TPC
3859// In order to avoid a huge monolithic routine, this method actually
3860// calls inner methods to create and assemble the various (macro)pieces
3861//
3862// Input:
3863// moth : the TGeoVolume owing the volume structure
3864// mgr : the GeoManager (default gGeoManager)
3865// Output:
3866//
3867// Created: 14 Dec 2009 Mario Sitta
3868//
3869
3870 SDDCableTraysSideA(moth, mgr);
aa177c73 3871 SDDCableTraysSideC(moth, mgr);
798b4e0c 3872
3873 return;
3874}
3875
3876//______________________________________________________________________
3877void AliITSv11GeometrySupport::ServicesCableSupportSSD(TGeoVolume *moth,
3878 TGeoManager *mgr){
3879//
3880// Creates the SSD cable trays which are outside the ITS support cones
3881// but still inside the TPC
3882// In order to avoid a huge monolithic routine, this method actually
3883// calls inner methods to create and assemble the various (macro)pieces
3884//
3885// Input:
3886// moth : the TGeoVolume owing the volume structure
3887// mgr : the GeoManager (default gGeoManager)
3888// Output:
3889//
3890// Created: 15 Nov 2009 Mario Sitta
3891//
3892
3893 SSDCableTraysSideA(moth, mgr);
aa177c73 3894 SSDCableTraysSideC(moth, mgr);
798b4e0c 3895
3896 return;
3897}
3898
3899//______________________________________________________________________
3900void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
43aefea7 3901 const TGeoManager *mgr){
798b4e0c 3902//
3903// Creates the SPD cable trays which are outside the ITS support cones
3904// but still inside the TPC on Side A
3905// (part of this code is taken or anyway inspired to ServicesCableSupport
3906// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
3907//
3908// Input:
3909// moth : the TGeoVolume owing the volume structure
3910// mgr : the GeoManager (default gGeoManager)
3911// Output:
3912//
3913// Created: 15 Feb 2010 Mario Sitta
96eb8210 3914// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes
57126ea1 3915// Updated: 08 Sep 2010 Mario Sitta
1c5895a3 3916// Updated: 14 Sep 2010 Mario Sitta Cables prolonged till cone
798b4e0c 3917//
3918// Technical data are taken from AutoCAD drawings, L.Simonetti technical
3919// drawings and other (oral) information given by F.Tosello and D.Elia
3920// (small differences with blueprints - e.g. -0.07mm in R1Trans and
3921// R2Trans - fix small overlaps; they are then compensated in positioning
3922// the Rear Tray to avoid its own overlaps with the rear supporting ring)
57126ea1 3923// Optical fibers and voltage cables are approximated with mean materials
3924// and square cross sections, but preserving the total material budget.
798b4e0c 3925//
3926
3927 // Overall position and rotation of the A-Side Cable Trays
3928 // (parts of 0872/G/D)
3929 const Double_t kTrayAR1Trans = 396.93 *fgkmm;
3930 const Double_t kTrayAR2Trans = 413.93 *fgkmm;
3931 const Double_t kTrayAZTrans = 1011.00 *fgkmm;
3932 const Double_t kTrayAZRot = (180-169.5);// Degrees
3933 const Double_t kTrayAFirstRotAng = 22.00; // Degrees
3934 const Double_t kTrayASecondRotAng = 15.00; // Degrees
3935
3936 const Double_t kForwardTrayWide = 94.00 *fgkmm;//!!!TO BE CHECKED!!!
3937 const Double_t kForwardTrayFirstHigh = 83.00 *fgkmm;//!!!TO BE CHECKED!!!
3938 const Double_t kForwardTraySecondHigh = 52.70 *fgkmm;//!!!TO BE CHECKED!!!
3939 const Double_t kForwardTrayTotalLen = 853.00 *fgkmm;
3940 const Double_t kForwardTrayFirstLen = 435.00 *fgkmm;
3941 const Double_t kForwardTrayWingWide = 16.00 *fgkmm;//!!!TO BE CHECKED!!!
3942 const Double_t kForwardTrayInterSpace = 18.00 *fgkmm;//!!!TO BE CHECKED!!!
3943 const Double_t kForwardTrayThick = 2.00 *fgkmm;
3944
1c5895a3 3945 const Int_t kForwardSideNpoints = 6;
798b4e0c 3946
3947 const Double_t kExternalTrayLen = 1200.00 *fgkmm;
3948 const Double_t kExternalTrayWide = kForwardTrayWide;
3949 const Double_t kExternalTrayHigh = kForwardTraySecondHigh;
3950 const Double_t kExternalTrayThick = kForwardTrayThick;
3951
57126ea1 3952 const Double_t kCoolingTubeRmin = 2.00 *fgkmm;
3953 const Double_t kCoolingTubeRmax = 3.00 *fgkmm;
798b4e0c 3954
3955 const Double_t kOpticalFibersSect = 8.696*fgkmm;//!!!ESTIMATED!!!
57126ea1 3956 const Double_t kLowVoltageCableSectCu = 7.675*fgkmm;// Computed
3957 const Double_t kLowVoltageCableHighPUR = 1.000*fgkmm;// Computed
3958 const Double_t kHiVoltageCableSectCu = 1.535*fgkmm;// Computed
3959 const Double_t kHiVoltageCableHighPUR = 0.500*fgkmm;// Computed
d8826f33 3960 const Double_t kCoaxCableSectCu = 6.024*fgkmm;// Computed
3961 const Double_t kCoaxCableHighMeg = 5.695*fgkmm;// Computed
96eb8210 3962
1c5895a3 3963 const Double_t kTrayCCablesRot = 75.000*fgkDegree;// Computed
3964 const Double_t kTrayCCablesZLenOut = 227.000*fgkmm;// Computed
3965
798b4e0c 3966
3967 // Local variables
3968 Double_t xprof[kForwardSideNpoints], yprof[kForwardSideNpoints];
3969 Double_t xloc, yloc, zloc, alpharot;
3970
3971
3972 // The two tray components as assemblies
3973 TGeoVolumeAssembly *cableTrayAForw =
3974 new TGeoVolumeAssembly("ITSsupportSPDTrayAForwRear");
3975 TGeoVolumeAssembly *cableTrayAExt =
3976 new TGeoVolumeAssembly("ITSsupportSPDTrayAExt");
3977
3978
3979 // First create all needed shapes
3980
3981 // The lower face of the forward tray: a BBox
3982 TGeoBBox *forwTrayLowerFace = new TGeoBBox(kForwardTrayWide/2,
3983 kForwardTrayThick/2,
3984 kForwardTrayTotalLen/2);
3985
3986 // The side face of the forward tray: a Xtru
3987 TGeoXtru *forwTraySideFace = new TGeoXtru(2);
3988 forwTraySideFace->SetName("ITSsuppSPDForwTraySide");
3989
3990 xprof[0] = 0;
3991 yprof[0] = kForwardTrayThick;
3992 xprof[1] = kForwardTrayTotalLen;
3993 yprof[1] = yprof[0];
3994 xprof[2] = xprof[1];
3995 yprof[2] = kForwardTraySecondHigh - kForwardTrayThick;
3996 xprof[3] = kForwardTrayFirstLen;
3997 yprof[3] = yprof[2];
3998 xprof[4] = xprof[3];
3999 yprof[4] = kForwardTrayFirstHigh - kForwardTrayThick;
4000 xprof[5] = xprof[0];
4001 yprof[5] = yprof[4];
4002
4003 forwTraySideFace->DefinePolygon(6, xprof, yprof);
4004 forwTraySideFace->DefineSection(0, 0);
4005 forwTraySideFace->DefineSection(1, kForwardTrayThick);
4006
4007 // The covers of the forward tray: two BBox's
4008 TGeoBBox *forwTrayShortCover = new TGeoBBox(kForwardTrayWide/2,
4009 kForwardTrayThick/2,
4010 kForwardTrayFirstLen/2);
4011
4012 TGeoBBox *forwTrayLongCover = new TGeoBBox(kForwardTrayWide/2,
4013 kForwardTrayThick/2,
4014 (kForwardTrayTotalLen - kForwardTrayFirstLen)/2);
4015
4016 // Each small wing of the forward tray: a BBox
4017 TGeoBBox *forwTrayWing = new TGeoBBox(kForwardTrayWingWide/2,
4018 (kForwardTrayFirstHigh-kForwardTraySecondHigh)/2,
4019 kForwardTrayThick/2);
4020
4021 // The internal plane of the forward tray: a BBox
4022 TGeoBBox *forwTrayPlane = new TGeoBBox(kForwardTrayWide/2-kForwardTrayThick,
4023 kForwardTrayThick/2,
4024 kForwardTrayTotalLen/2);
4025
4026 // The internal wall of the forward tray: a BBox
4027 TGeoBBox *forwTrayWall = new TGeoBBox(kForwardTrayThick/2,
4028 (kForwardTrayInterSpace-kForwardTrayThick)/2,
4029 kForwardTrayTotalLen/2);
4030
4031 // Each horizontal face of the external tray: a BBox
4032 TGeoBBox *extTrayHorFace = new TGeoBBox(kExternalTrayWide/2-kExternalTrayThick,
4033 kExternalTrayThick/2,
4034 kExternalTrayLen/2);
4035
4036 // Each vertical face of the external tray: a BBox
4037 TGeoBBox *extTrayVerFace = new TGeoBBox(kExternalTrayThick/2,
4038 kExternalTrayHigh/2,
4039 kExternalTrayLen/2);
4040
4041 // The internal wall of the external tray: a BBox
4042 TGeoBBox *extTrayWall = new TGeoBBox(kExternalTrayThick/2,
4043 (kForwardTrayInterSpace-kExternalTrayThick)/2,
4044 kExternalTrayLen/2);
4045
96eb8210 4046 // The cooling tube inside the forward tray: a Tube
798b4e0c 4047 Double_t zelong = (kForwardTraySecondHigh - 2*kForwardTrayThick
4048 - 2*forwTrayWall->GetDY() - kCoolingTubeRmax)*SinD(kTrayAZRot);
4049 Double_t zlen = (zelong + kForwardTrayTotalLen)/2;
96eb8210 4050 TGeoTube *coolTubeForw = new TGeoTube(0, kCoolingTubeRmax, zlen);
4051
4052 // The freon inside the forward tray tubes: a Tube
4053 TGeoTube *freonTubeForw = new TGeoTube(0, kCoolingTubeRmin, zlen);
798b4e0c 4054
4055 // The cooling tube inside the external tray: a Ctub
96eb8210 4056 TGeoCtub *coolTubeExt = new TGeoCtub(0, kCoolingTubeRmax,
798b4e0c 4057 kExternalTrayLen/2, 0, 360,
4058 0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
4059 0, 0, 1);
4060
96eb8210 4061 // The freon inside the forward tray tubes: a Tube
4062 TGeoCtub *freonTubeExt = new TGeoCtub(0, kCoolingTubeRmin,
4063 kExternalTrayLen/2, 0, 360,
4064 0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
4065 0, 0, 1);
4066
1c5895a3 4067 // The optical fibers inside the forward tray: a Xtru
4068 TGeoXtru *optFibsForw = new TGeoXtru(2);
4069
4070 xprof[0] = -kTrayCCablesZLenOut;
4071 yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
4072 xprof[1] = 0;
4073 yprof[1] = 0;
4074 xprof[2] = kForwardTrayTotalLen;
4075 yprof[2] = yprof[1];
4076 xprof[3] = xprof[2];
4077 yprof[3] = yprof[2] + kOpticalFibersSect;
4078 xprof[4] = xprof[1];
4079 yprof[4] = yprof[3];
4080 xprof[5] = xprof[0];
4081 yprof[5] = yprof[0] + kOpticalFibersSect;
4082
4083 optFibsForw->DefinePolygon(6, xprof, yprof);
4084 optFibsForw->DefineSection(0,-kOpticalFibersSect/2);
4085 optFibsForw->DefineSection(1, kOpticalFibersSect/2);
798b4e0c 4086
4087 // The optical fibers inside the external tray: a Xtru
4088 TGeoXtru *optFibsExt = new TGeoXtru(2);
1c5895a3 4089 optFibsExt->SetName("ITSsuppSPDExtTrayOptFibs");
798b4e0c 4090
4091 yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
4092 + 2*forwTrayWall->GetDY();
4093 xprof[0] = yprof[0]*TanD(kTrayAZRot);
4094 xprof[1] = kExternalTrayLen;
4095 yprof[1] = yprof[0];
4096 xprof[2] = xprof[1];
4097 yprof[2] = yprof[1] + kOpticalFibersSect;
4098 yprof[3] = yprof[2];
4099 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4100
4101 optFibsExt->DefinePolygon(4, xprof, yprof);
4102 optFibsExt->DefineSection(0, 0);
4103 optFibsExt->DefineSection(1, kOpticalFibersSect);
4104
1c5895a3 4105 // The Low Voltage cables inside the forward tray: two Xtru
4106 TGeoXtru *lowCablesForwCu = new TGeoXtru(2);
4107
4108 xprof[0] = -kTrayCCablesZLenOut;
4109 yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
4110 xprof[1] = 0;
4111 yprof[1] = 0;
4112 xprof[2] = kForwardTrayTotalLen;
4113 yprof[2] = yprof[1];
4114 xprof[3] = xprof[2];
4115 yprof[3] = yprof[2] + kLowVoltageCableSectCu/2;
4116 xprof[4] = xprof[1];
4117 yprof[4] = yprof[3];
4118 xprof[5] = xprof[0];
4119 yprof[5] = yprof[0] + kLowVoltageCableSectCu/2;
4120
4121 lowCablesForwCu->DefinePolygon(6, xprof, yprof);
4122 lowCablesForwCu->DefineSection(0,-kLowVoltageCableSectCu);
4123 lowCablesForwCu->DefineSection(1, kLowVoltageCableSectCu);
57126ea1 4124
1c5895a3 4125 TGeoXtru *lowCablesForwPUR = new TGeoXtru(2);
4126
4127 xprof[0] = lowCablesForwCu->GetX(5);
4128 yprof[0] = lowCablesForwCu->GetY(5);
4129 xprof[1] = lowCablesForwCu->GetX(4);
4130 yprof[1] = lowCablesForwCu->GetY(4);
4131 xprof[2] = lowCablesForwCu->GetX(3);
4132 yprof[2] = lowCablesForwCu->GetY(3);
4133 xprof[3] = xprof[2];
4134 yprof[3] = yprof[2] + kLowVoltageCableHighPUR/2;
4135 xprof[4] = xprof[1];
4136 yprof[4] = yprof[3];
4137 xprof[5] = xprof[0];
4138 yprof[5] = yprof[0] + kLowVoltageCableHighPUR/2;
4139
4140 lowCablesForwPUR->DefinePolygon(6, xprof, yprof);
4141 lowCablesForwPUR->DefineSection(0,-kLowVoltageCableSectCu);
4142 lowCablesForwPUR->DefineSection(1, kLowVoltageCableSectCu);
798b4e0c 4143
57126ea1 4144 // The Low Voltage inside the external tray: two Xtru
4145 TGeoXtru *lowCablesExtCu = new TGeoXtru(2);
4146 lowCablesExtCu->SetName("ITSsuppSPDExtTrayLowVoltageCu");
798b4e0c 4147
4148 yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
4149 + 2*forwTrayWall->GetDY();
4150 xprof[0] = yprof[0]*TanD(kTrayAZRot);
4151 xprof[1] = kExternalTrayLen;
4152 yprof[1] = yprof[0];
4153 xprof[2] = xprof[1];
57126ea1 4154 yprof[2] = yprof[1] + kLowVoltageCableSectCu/2;
798b4e0c 4155 yprof[3] = yprof[2];
4156 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4157
57126ea1 4158 lowCablesExtCu->DefinePolygon(4, xprof, yprof);
4159 lowCablesExtCu->DefineSection(0, 0);
4160 lowCablesExtCu->DefineSection(1, kLowVoltageCableSectCu*2);
798b4e0c 4161
57126ea1 4162 TGeoXtru *lowCablesExtPUR = new TGeoXtru(2);
4163 lowCablesExtPUR->SetName("ITSsuppSPDExtTrayLowVoltagePUR");
4164
4165 xprof[0] = lowCablesExtCu->GetX(3);
4166 yprof[0] = lowCablesExtCu->GetY(3);
4167 xprof[1] = lowCablesExtCu->GetX(2);
4168 yprof[1] = lowCablesExtCu->GetY(2);
4169 xprof[2] = xprof[1];
4170 yprof[2] = yprof[1] + kLowVoltageCableHighPUR/2;
4171 yprof[3] = yprof[2];
4172 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4173
4174 lowCablesExtPUR->DefinePolygon(4, xprof, yprof);
4175 lowCablesExtPUR->DefineSection(0, 0);
4176 lowCablesExtPUR->DefineSection(1, kLowVoltageCableSectCu*2);
4177
1c5895a3 4178 // The High Voltage cables inside the forward tray: two Xtru
4179 TGeoXtru *hiCablesForwCu = new TGeoXtru(2);
96eb8210 4180
1c5895a3 4181 xprof[0] = -kTrayCCablesZLenOut;
4182 yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
4183 xprof[1] = 0;
4184 yprof[1] = 0;
4185 xprof[2] = kForwardTrayTotalLen;
4186 yprof[2] = yprof[1];
4187 xprof[3] = xprof[2];
4188 yprof[3] = yprof[2] + kHiVoltageCableSectCu/2;
4189 xprof[4] = xprof[1];
4190 yprof[4] = yprof[3];
4191 xprof[5] = xprof[0];
4192 yprof[5] = yprof[0] + kHiVoltageCableSectCu/2;
4193
4194 hiCablesForwCu->DefinePolygon(6, xprof, yprof);
4195 hiCablesForwCu->DefineSection(0,-kHiVoltageCableSectCu);
4196 hiCablesForwCu->DefineSection(1, kHiVoltageCableSectCu);
4197
4198 TGeoXtru *hiCablesForwPUR = new TGeoXtru(2);
4199
4200 xprof[0] = hiCablesForwCu->GetX(5);
4201 yprof[0] = hiCablesForwCu->GetY(5);
4202 xprof[1] = hiCablesForwCu->GetX(4);
4203 yprof[1] = hiCablesForwCu->GetY(4);
4204 xprof[2] = hiCablesForwCu->GetX(3);
4205 yprof[2] = hiCablesForwCu->GetY(3);
4206 xprof[3] = xprof[2];
4207 yprof[3] = yprof[2] + kHiVoltageCableHighPUR/2;
4208 xprof[4] = xprof[1];
4209 yprof[4] = yprof[3];
4210 xprof[5] = xprof[0];
4211 yprof[5] = yprof[0] + kHiVoltageCableHighPUR/2;
4212
4213 hiCablesForwPUR->DefinePolygon(6, xprof, yprof);
4214 hiCablesForwPUR->DefineSection(0,-kHiVoltageCableSectCu);
4215 hiCablesForwPUR->DefineSection(1, kHiVoltageCableSectCu);
57126ea1 4216
4217 // The High Voltage inside the external tray: two Xtru
4218 TGeoXtru *hiCablesExtCu = new TGeoXtru(2);
4219 hiCablesExtCu->SetName("ITSsuppSPDExtTrayHiVoltageCu");
96eb8210 4220
4221 yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
4222 + 2*forwTrayWall->GetDY();
4223 xprof[0] = yprof[0]*TanD(kTrayAZRot);
4224 xprof[1] = kExternalTrayLen;
4225 yprof[1] = yprof[0];
4226 xprof[2] = xprof[1];
57126ea1 4227 yprof[2] = yprof[1] + kHiVoltageCableSectCu/2;
4228 yprof[3] = yprof[2];
4229 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4230
4231 hiCablesExtCu->DefinePolygon(4, xprof, yprof);
4232 hiCablesExtCu->DefineSection(0, 0);
4233 hiCablesExtCu->DefineSection(1, kHiVoltageCableSectCu*2);
4234
4235 TGeoXtru *hiCablesExtPUR = new TGeoXtru(2);
4236 hiCablesExtPUR->SetName("ITSsuppSPDExtTrayHiVoltagePUR");
4237
4238 xprof[0] = hiCablesExtCu->GetX(3);
4239 yprof[0] = hiCablesExtCu->GetY(3);
4240 xprof[1] = hiCablesExtCu->GetX(2);
4241 yprof[1] = hiCablesExtCu->GetY(2);
4242 xprof[2] = xprof[1];
4243 yprof[2] = yprof[1] + kHiVoltageCableHighPUR/2;
4244 yprof[3] = yprof[2];
4245 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4246
4247 hiCablesExtPUR->DefinePolygon(4, xprof, yprof);
4248 hiCablesExtPUR->DefineSection(0, 0);
4249 hiCablesExtPUR->DefineSection(1, kHiVoltageCableSectCu*2);
4250
1c5895a3 4251 // The Coaxial cables inside the forward tray: two Xtru
4252 TGeoXtru *coaxCablesForwCu = new TGeoXtru(2);
d8826f33 4253 coaxCablesForwCu->SetName("ITSsuppSPDForwTrayCoaxCu");
57126ea1 4254
1c5895a3 4255 xprof[0] = -kTrayCCablesZLenOut;
4256 yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
4257 xprof[1] = 0;
4258 yprof[1] = 0;
4259 xprof[2] = kForwardTrayTotalLen;
4260 yprof[2] = yprof[1];
4261 xprof[3] = xprof[2];
4262 yprof[3] = yprof[2] + kCoaxCableSectCu/2;
4263 xprof[4] = xprof[1];
4264 yprof[4] = yprof[3];
4265 xprof[5] = xprof[0];
4266 yprof[5] = yprof[0] + kCoaxCableSectCu/2;
4267
4268 coaxCablesForwCu->DefinePolygon(6, xprof, yprof);
4269 coaxCablesForwCu->DefineSection(0,-kCoaxCableSectCu);
4270 coaxCablesForwCu->DefineSection(1, kCoaxCableSectCu);
4271
d8826f33 4272 TGeoXtru *coaxCablesForwMeg = new TGeoXtru(2);
4273 coaxCablesForwMeg->SetName("ITSsuppSPDForwTrayCoaxMeg");
1c5895a3 4274
4275 xprof[0] = coaxCablesForwCu->GetX(5);
4276 yprof[0] = coaxCablesForwCu->GetY(5);
4277 xprof[1] = coaxCablesForwCu->GetX(4);
4278 yprof[1] = coaxCablesForwCu->GetY(4);
4279 xprof[2] = coaxCablesForwCu->GetX(3);
4280 yprof[2] = coaxCablesForwCu->GetY(3);
4281 xprof[3] = xprof[2];
d8826f33 4282 yprof[3] = yprof[2] + kCoaxCableHighMeg/2;
1c5895a3 4283 xprof[4] = xprof[1];
4284 yprof[4] = yprof[3];
4285 xprof[5] = xprof[0];
d8826f33 4286 yprof[5] = yprof[0] + kCoaxCableHighMeg/2;
1c5895a3 4287
d8826f33 4288 coaxCablesForwMeg->DefinePolygon(6, xprof, yprof);
4289 coaxCablesForwMeg->DefineSection(0,-kCoaxCableSectCu);
4290 coaxCablesForwMeg->DefineSection(1, kCoaxCableSectCu);
57126ea1 4291
4292 // The Coaxial inside the external tray: two Xtru
4293 TGeoXtru *coaxCablesExtCu = new TGeoXtru(2);
4294 coaxCablesExtCu->SetName("ITSsuppSPDExtTrayCoaxCu");
4295
4296 yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
4297 + 2*forwTrayWall->GetDY();
4298 xprof[0] = yprof[0]*TanD(kTrayAZRot);
4299 xprof[1] = kExternalTrayLen;
4300 yprof[1] = yprof[0];
4301 xprof[2] = xprof[1];
4302 yprof[2] = yprof[1] + kCoaxCableSectCu/2;
4303 yprof[3] = yprof[2];
4304 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4305
4306 coaxCablesExtCu->DefinePolygon(4, xprof, yprof);
4307 coaxCablesExtCu->DefineSection(0, 0);
4308 coaxCablesExtCu->DefineSection(1, kCoaxCableSectCu*2);
4309
d8826f33 4310 TGeoXtru *coaxCablesExtMeg = new TGeoXtru(2);
4311 coaxCablesExtMeg->SetName("ITSsuppSPDExtTrayCoaxMeg");
57126ea1 4312
4313 xprof[0] = coaxCablesExtCu->GetX(3);
4314 yprof[0] = coaxCablesExtCu->GetY(3);
4315 xprof[1] = coaxCablesExtCu->GetX(2);
4316 yprof[1] = coaxCablesExtCu->GetY(2);
4317 xprof[2] = xprof[1];
d8826f33 4318 yprof[2] = yprof[1] + kCoaxCableHighMeg/2;
96eb8210 4319 yprof[3] = yprof[2];
4320 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4321
d8826f33 4322 coaxCablesExtMeg->DefinePolygon(4, xprof, yprof);
4323 coaxCablesExtMeg->DefineSection(0, 0);
4324 coaxCablesExtMeg->DefineSection(1, kCoaxCableSectCu*2);
96eb8210 4325
798b4e0c 4326
4327 // We have all shapes: now create the real volumes
0801d201 4328 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
4329 TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$");
96eb8210 4330 TGeoMedium *medFreon = mgr->GetMedium("ITS_GASEOUS FREON$");
0801d201 4331 TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!TO BE CHECKED!
4332 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
4333 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
d8826f33 4334 TGeoMedium *medMeg = mgr->GetMedium("ITS_MEGOLON$");
798b4e0c 4335
4336 TGeoVolume *forwTrayABase = new TGeoVolume("ITSsuppSPDSideAForwTrayABase",
4337 forwTrayLowerFace, medAl);
4338
4339 forwTrayABase->SetVisibility(kTRUE);
4340 forwTrayABase->SetLineColor(6); // Purple
4341 forwTrayABase->SetLineWidth(1);
4342 forwTrayABase->SetFillColor(forwTrayABase->GetLineColor());
4343 forwTrayABase->SetFillStyle(4000); // 0% transparent
4344
4345 TGeoVolume *forwTrayASide = new TGeoVolume("ITSsuppSPDSideAForwTrayASide",
4346 forwTraySideFace, medAl);
4347
4348 forwTrayASide->SetVisibility(kTRUE);
4349 forwTrayASide->SetLineColor(6); // Purple
4350 forwTrayASide->SetLineWidth(1);
4351 forwTrayASide->SetFillColor(forwTrayASide->GetLineColor());
4352 forwTrayASide->SetFillStyle(4000); // 0% transparent
4353
4354 TGeoVolume *forwTrayACoverShort = new TGeoVolume("ITSsuppSPDSideAForwTrayASC",
4355 forwTrayShortCover, medAl);
4356
4357 forwTrayACoverShort->SetVisibility(kTRUE);
4358 forwTrayACoverShort->SetLineColor(6); // Purple
4359 forwTrayACoverShort->SetLineWidth(1);
4360 forwTrayACoverShort->SetFillColor(forwTrayACoverShort->GetLineColor());
4361 forwTrayACoverShort->SetFillStyle(4000); // 0% transparent
4362
4363 TGeoVolume *forwTrayACoverLong = new TGeoVolume("ITSsuppSPDSideAForwTrayALC",
4364 forwTrayLongCover, medAl);
4365
4366 forwTrayACoverLong->SetVisibility(kTRUE);
4367 forwTrayACoverLong->SetLineColor(6); // Purple
4368 forwTrayACoverLong->SetLineWidth(1);
4369 forwTrayACoverLong->SetFillColor(forwTrayACoverLong->GetLineColor());
4370 forwTrayACoverLong->SetFillStyle(4000); // 0% transparent
4371
4372 TGeoVolume *forwTrayAWing = new TGeoVolume("ITSsuppSPDSideAForwTrayAWing",
4373 forwTrayWing, medAl);
4374
4375 forwTrayAWing->SetVisibility(kTRUE);
4376 forwTrayAWing->SetLineColor(6); // Purple
4377 forwTrayAWing->SetLineWidth(1);
4378 forwTrayAWing->SetFillColor(forwTrayAWing->GetLineColor());
4379 forwTrayAWing->SetFillStyle(4000); // 0% transparent
4380
4381 TGeoVolume *forwTrayAPlane = new TGeoVolume("ITSsuppSPDSideAForwTrayAPlane",
4382 forwTrayPlane, medAl);
4383
4384 forwTrayAPlane->SetVisibility(kTRUE);
4385 forwTrayAPlane->SetLineColor(6); // Purple
4386 forwTrayAPlane->SetLineWidth(1);
4387 forwTrayAPlane->SetFillColor(forwTrayAPlane->GetLineColor());
4388 forwTrayAPlane->SetFillStyle(4000); // 0% transparent
4389
4390 TGeoVolume *forwTrayAWall = new TGeoVolume("ITSsuppSPDSideAForwTrayAWall",
4391 forwTrayWall, medAl);
4392
4393 forwTrayAWall->SetVisibility(kTRUE);
4394 forwTrayAWall->SetLineColor(6); // Purple
4395 forwTrayAWall->SetLineWidth(1);
4396 forwTrayAWall->SetFillColor(forwTrayAWall->GetLineColor());
4397 forwTrayAWall->SetFillStyle(4000); // 0% transparent
4398
4399 TGeoVolume *extTrayAHorFace = new TGeoVolume("ITSsuppSPDSideAExtTrayHorFace",
4400 extTrayHorFace, medAl);
4401
4402 extTrayAHorFace->SetVisibility(kTRUE);
4403 extTrayAHorFace->SetLineColor(6); // Purple
4404 extTrayAHorFace->SetLineWidth(1);
4405 extTrayAHorFace->SetFillColor(extTrayAHorFace->GetLineColor());
4406 extTrayAHorFace->SetFillStyle(4000); // 0% transparent
4407
4408 TGeoVolume *extTrayAVerFace = new TGeoVolume("ITSsuppSPDSideAExtTrayVerFace",
4409 extTrayVerFace, medAl);
4410
4411 extTrayAVerFace->SetVisibility(kTRUE);
4412 extTrayAVerFace->SetLineColor(6); // Purple
4413 extTrayAVerFace->SetLineWidth(1);
4414 extTrayAVerFace->SetFillColor(extTrayAVerFace->GetLineColor());
4415 extTrayAVerFace->SetFillStyle(4000); // 0% transparent
4416
4417 TGeoVolume *extTrayAWall = new TGeoVolume("ITSsuppSPDSideAExtTrayWall",
4418 extTrayWall, medAl);
4419
4420 extTrayAWall->SetVisibility(kTRUE);
4421 extTrayAWall->SetLineColor(6); // Purple
4422 extTrayAWall->SetLineWidth(1);
4423 extTrayAWall->SetFillColor(extTrayAWall->GetLineColor());
4424 extTrayAWall->SetFillStyle(4000); // 0% transparent
4425
4426 TGeoVolume *forwCoolTube = new TGeoVolume("ITSsuppSPDSideAForwTrayCoolTube",
4427 coolTubeForw, medIn);
4428
4429 forwCoolTube->SetVisibility(kTRUE);
4430 forwCoolTube->SetLineColor(kGray); // as in GeometrySPD
4431 forwCoolTube->SetLineWidth(1);
4432 forwCoolTube->SetFillColor(forwCoolTube->GetLineColor());
4433 forwCoolTube->SetFillStyle(4000); // 0% transparent
4434
96eb8210 4435 TGeoVolume *forwCoolFreon = new TGeoVolume("ITSsuppSPDSideAForwTrayFreon",
4436 freonTubeForw, medFreon);
4437
4438 forwCoolFreon->SetVisibility(kTRUE);
4439 forwCoolFreon->SetLineColor(kBlue); // Blue
4440 forwCoolFreon->SetLineWidth(1);
4441 forwCoolFreon->SetFillColor(forwCoolFreon->GetLineColor());
4442 forwCoolFreon->SetFillStyle(4000); // 0% transparent
4443
798b4e0c 4444 TGeoVolume *extCoolTube = new TGeoVolume("ITSsuppSPDSideAExtTrayCoolTube",
4445 coolTubeExt, medIn);
4446
4447 extCoolTube->SetVisibility(kTRUE);
4448 extCoolTube->SetLineColor(kGray); // as in GeometrySPD
4449 extCoolTube->SetLineWidth(1);
4450 extCoolTube->SetFillColor(extCoolTube->GetLineColor());
4451 extCoolTube->SetFillStyle(4000); // 0% transparent
4452
96eb8210 4453 TGeoVolume *extCoolFreon = new TGeoVolume("ITSsuppSPDSideAExtTrayFreon",
4454 freonTubeExt, medFreon);
4455
4456 extCoolFreon->SetVisibility(kTRUE);
4457 extCoolFreon->SetLineColor(kBlue); // Blue
4458 extCoolFreon->SetLineWidth(1);
4459 extCoolFreon->SetFillColor(extCoolFreon->GetLineColor());
4460 extCoolFreon->SetFillStyle(4000); // 0% transparent
4461
798b4e0c 4462 TGeoVolume *forwOptFibs = new TGeoVolume("ITSsuppSPDSideAForwTrayOptFibs",
4463 optFibsForw, medFibs);
4464
4465 forwOptFibs->SetVisibility(kTRUE);
4466 forwOptFibs->SetLineColor(kOrange); // Orange
4467 forwOptFibs->SetLineWidth(1);
4468 forwOptFibs->SetFillColor(forwOptFibs->GetLineColor());
4469 forwOptFibs->SetFillStyle(4000); // 0% transparent
4470
4471 TGeoVolume *extOptFibs = new TGeoVolume("ITSsuppSPDSideAExtTrayOptFibs",
4472 optFibsExt, medFibs);
4473
4474 extOptFibs->SetVisibility(kTRUE);
4475 extOptFibs->SetLineColor(kOrange); // Orange
4476 extOptFibs->SetLineWidth(1);
4477 extOptFibs->SetFillColor(extOptFibs->GetLineColor());
4478 extOptFibs->SetFillStyle(4000); // 0% transparent
4479
57126ea1 4480 TGeoVolume *forwLowCabsCu = new TGeoVolume("ITSsuppSPDSideAForwLowCabsCu",
4481 lowCablesForwCu, medCu);
4482
4483 forwLowCabsCu->SetVisibility(kTRUE);
4484 forwLowCabsCu->SetLineColor(kRed); // Red
4485 forwLowCabsCu->SetLineWidth(1);
4486 forwLowCabsCu->SetFillColor(forwLowCabsCu->GetLineColor());
4487 forwLowCabsCu->SetFillStyle(4000); // 0% transparent
4488
4489 TGeoVolume *forwLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwLowCabsPUR",
4490 lowCablesForwPUR, medPUR);
4491
4492 forwLowCabsPUR->SetVisibility(kTRUE);
4493 forwLowCabsPUR->SetLineColor(kBlack); // Black
4494 forwLowCabsPUR->SetLineWidth(1);
4495 forwLowCabsPUR->SetFillColor(forwLowCabsPUR->GetLineColor());
4496 forwLowCabsPUR->SetFillStyle(4000); // 0% transparent
4497
4498 TGeoVolume *extLowCabsCu = new TGeoVolume("ITSsuppSPDSideAExtLowCabsCu",
4499 lowCablesExtCu, medCu);
4500
4501 extLowCabsCu->SetVisibility(kTRUE);
4502 extLowCabsCu->SetLineColor(kRed); // Red
4503 extLowCabsCu->SetLineWidth(1);
4504 extLowCabsCu->SetFillColor(extLowCabsCu->GetLineColor());
4505 extLowCabsCu->SetFillStyle(4000); // 0% transparent
4506
4507 TGeoVolume *extLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtLowCabsPUR",
4508 lowCablesExtPUR, medPUR);
4509
4510 extLowCabsPUR->SetVisibility(kTRUE);
4511 extLowCabsPUR->SetLineColor(kBlack); // Black
4512 extLowCabsPUR->SetLineWidth(1);
4513 extLowCabsPUR->SetFillColor(extLowCabsPUR->GetLineColor());
4514 extLowCabsPUR->SetFillStyle(4000); // 0% transparent
4515
4516 TGeoVolume *forwHiCabsCu = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsCu",
4517 hiCablesForwCu, medCu);
4518
4519 forwHiCabsCu->SetVisibility(kTRUE);
4520 forwHiCabsCu->SetLineColor(kRed); // Red
4521 forwHiCabsCu->SetLineWidth(1);
4522 forwHiCabsCu->SetFillColor(forwHiCabsCu->GetLineColor());
4523 forwHiCabsCu->SetFillStyle(4000); // 0% transparent
4524
4525 TGeoVolume *forwHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsPUR",
4526 hiCablesForwPUR, medPUR);
4527
4528 forwHiCabsPUR->SetVisibility(kTRUE);
4529 forwHiCabsPUR->SetLineColor(kBlack); // Black
4530 forwHiCabsPUR->SetLineWidth(1);
4531 forwHiCabsPUR->SetFillColor(forwHiCabsPUR->GetLineColor());
4532 forwHiCabsPUR->SetFillStyle(4000); // 0% transparent
4533
4534 TGeoVolume *extHiCabsCu = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsCu",
4535 hiCablesExtCu, medCu);
4536
4537 extHiCabsCu->SetVisibility(kTRUE);
4538 extHiCabsCu->SetLineColor(kRed); // Red
4539 extHiCabsCu->SetLineWidth(1);
4540 extHiCabsCu->SetFillColor(extHiCabsCu->GetLineColor());
4541 extHiCabsCu->SetFillStyle(4000); // 0% transparent
4542
4543 TGeoVolume *extHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsPUR",
4544 hiCablesExtPUR, medPUR);
4545
4546 extHiCabsPUR->SetVisibility(kTRUE);
4547 extHiCabsPUR->SetLineColor(kBlack); // Black
4548 extHiCabsPUR->SetLineWidth(1);
4549 extHiCabsPUR->SetFillColor(extHiCabsPUR->GetLineColor());
4550 extHiCabsPUR->SetFillStyle(4000); // 0% transparent
4551
4552 TGeoVolume *forwCoaxCu = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxCu",
4553 coaxCablesForwCu, medCu);
4554
4555 forwCoaxCu->SetVisibility(kTRUE);
4556 forwCoaxCu->SetLineColor(kRed); // Red
4557 forwCoaxCu->SetLineWidth(1);
4558 forwCoaxCu->SetFillColor(forwCoaxCu->GetLineColor());
4559 forwCoaxCu->SetFillStyle(4000); // 0% transparent
4560
d8826f33 4561 TGeoVolume *forwCoaxMeg = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxMeg",
4562 coaxCablesForwMeg, medMeg);
57126ea1 4563
d8826f33 4564 forwCoaxMeg->SetVisibility(kTRUE);
4565 forwCoaxMeg->SetLineColor(kBlack); // Black
4566 forwCoaxMeg->SetLineWidth(1);
4567 forwCoaxMeg->SetFillColor(forwCoaxMeg->GetLineColor());
4568 forwCoaxMeg->SetFillStyle(4000); // 0% transparent
57126ea1 4569
4570 TGeoVolume *extCoaxCu = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxCu",
4571 coaxCablesExtCu, medCu);
4572
4573 extCoaxCu->SetVisibility(kTRUE);
4574 extCoaxCu->SetLineColor(kRed); // Red
4575 extCoaxCu->SetLineWidth(1);
4576 extCoaxCu->SetFillColor(extCoaxCu->GetLineColor());
4577 extCoaxCu->SetFillStyle(4000); // 0% transparent
4578
d8826f33 4579 TGeoVolume *extCoaxMeg = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxMeg",
4580 coaxCablesExtMeg, medMeg);
57126ea1 4581
d8826f33 4582 extCoaxMeg->SetVisibility(kTRUE);
4583 extCoaxMeg->SetLineColor(kBlack); // Black
4584 extCoaxMeg->SetLineWidth(1);
4585 extCoaxMeg->SetFillColor(extCoaxMeg->GetLineColor());
4586 extCoaxMeg->SetFillStyle(4000); // 0% transparent
96eb8210 4587
798b4e0c 4588
4589 // Now build up the trays
4590 yloc = forwTrayLowerFace->GetDY();
4591 zloc = forwTrayLowerFace->GetDZ();
4592 cableTrayAForw->AddNode(forwTrayABase, 1,
4593 new TGeoTranslation(0, yloc, zloc));
4594
4595 xloc = kForwardTrayWide/2;
4596 cableTrayAForw->AddNode(forwTrayASide, 1,
4597 new TGeoCombiTrans( xloc, 0, 0,
4598 new TGeoRotation("",90,-90,-90)));
4599 cableTrayAForw->AddNode(forwTrayASide, 2,
4600 new TGeoCombiTrans(-xloc+kForwardTrayThick, 0, 0,
4601 new TGeoRotation("",90,-90,-90)));
4602
4603 yloc = kForwardTrayFirstHigh - forwTrayShortCover->GetDY();
4604 zloc = forwTrayShortCover->GetDZ();
4605 cableTrayAForw->AddNode(forwTrayACoverShort, 1,
4606 new TGeoTranslation(0, yloc, zloc));
4607
4608 yloc = kForwardTraySecondHigh - forwTrayLongCover->GetDY();
4609 zloc = kForwardTrayFirstLen + forwTrayLongCover->GetDZ();
4610 cableTrayAForw->AddNode(forwTrayACoverLong, 1,
4611 new TGeoTranslation(0, yloc, zloc));
4612
4613 xloc = kForwardTrayWide/2 - kForwardTrayThick - forwTrayWing->GetDX();
4614 yloc = kForwardTrayFirstHigh - kForwardTrayThick - forwTrayWing->GetDY();
4615 zloc = kForwardTrayFirstLen - forwTrayWing->GetDZ();
4616 cableTrayAForw->AddNode(forwTrayAWing, 1,
4617 new TGeoTranslation( xloc, yloc, zloc));
4618 cableTrayAForw->AddNode(forwTrayAWing, 2,
4619 new TGeoTranslation(-xloc, yloc, zloc));
4620
4621 yloc = kForwardTrayThick + kForwardTrayInterSpace - forwTrayPlane->GetDY();
4622 zloc = forwTrayPlane->GetDZ();
4623 cableTrayAForw->AddNode(forwTrayAPlane, 1,
4624 new TGeoTranslation(0, yloc, zloc));
4625
4626 yloc = kForwardTrayThick + forwTrayWall->GetDY();
4627 zloc = forwTrayWall->GetDZ();
4628 cableTrayAForw->AddNode(forwTrayAWall, 1,
4629 new TGeoTranslation(0, yloc, zloc));
4630
96eb8210 4631 forwCoolTube->AddNode(forwCoolFreon, 1, 0);
4632
798b4e0c 4633 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY()
4634 + coolTubeForw->GetRmax();
4635 zloc = coolTubeForw->GetDz();
4636 cableTrayAForw->AddNode(forwCoolTube, 1,
4637 new TGeoTranslation(0, yloc, zloc));
4638
1c5895a3 4639 xloc = optFibsForw->GetZ(1) + coolTubeForw->GetRmax();
4640 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
798b4e0c 4641 cableTrayAForw->AddNode(forwOptFibs, 1,
1c5895a3 4642 new TGeoCombiTrans( xloc, yloc, 0,
4643 new TGeoRotation("",-90.,90.,90.)));
798b4e0c 4644
0801d201 4645 xloc = lowCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
1c5895a3 4646 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
57126ea1 4647 cableTrayAForw->AddNode(forwLowCabsCu, 1,
0801d201 4648 new TGeoCombiTrans(-xloc, yloc, 0,
1c5895a3 4649 new TGeoRotation("",-90.,90.,90.)));
57126ea1 4650 cableTrayAForw->AddNode(forwLowCabsPUR, 1,
0801d201 4651 new TGeoCombiTrans(-xloc, yloc, 0,
1c5895a3 4652 new TGeoRotation("",-90.,90.,90.)));
798b4e0c 4653
0801d201 4654 xloc = 2*lowCablesForwCu->GetZ(1) +
1c5895a3 4655 hiCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
4656 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
57126ea1 4657 cableTrayAForw->AddNode(forwHiCabsCu, 1,
0801d201 4658 new TGeoCombiTrans(-xloc, yloc, 0,
1c5895a3 4659 new TGeoRotation("",-90.,90.,90.)));
57126ea1 4660 cableTrayAForw->AddNode(forwHiCabsPUR, 1,
0801d201 4661 new TGeoCombiTrans(-xloc, yloc, 0,
1c5895a3 4662 new TGeoRotation("",-90.,90.,90.)));
96eb8210 4663
0801d201 4664 xloc = 2*optFibsForw->GetZ(1) + coaxCablesForwCu->GetZ(1) +
4665 coolTubeForw->GetRmax();
1c5895a3 4666 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
57126ea1 4667 cableTrayAForw->AddNode(forwCoaxCu, 1,
0801d201 4668 new TGeoCombiTrans( xloc, yloc, 0,
1c5895a3 4669 new TGeoRotation("",-90.,90.,90.)));
d8826f33 4670 cableTrayAForw->AddNode(forwCoaxMeg, 1,
0801d201 4671 new TGeoCombiTrans( xloc, yloc, 0,
1c5895a3 4672 new TGeoRotation("",-90.,90.,90.)));
57126ea1 4673
798b4e0c 4674 // To simplify following placement in MARS, origin is on top
4675 yloc = -kExternalTrayHigh + kExternalTrayThick/2;
4676 zloc = kExternalTrayLen/2;
4677 cableTrayAExt->AddNode(extTrayAHorFace, 1,
4678 new TGeoTranslation( 0, yloc, zloc));
4679
4680 xloc = kExternalTrayWide/2 - kExternalTrayThick/2;
4681 yloc = -kExternalTrayHigh/2;
4682 cableTrayAExt->AddNode(extTrayAVerFace, 1,
4683 new TGeoTranslation( xloc, yloc, zloc));
4684 cableTrayAExt->AddNode(extTrayAVerFace, 2,
4685 new TGeoTranslation(-xloc, yloc, zloc));
4686
4687 yloc = -kExternalTrayThick/2;
4688 cableTrayAExt->AddNode(extTrayAHorFace, 2,
4689 new TGeoTranslation( 0, yloc, zloc));
4690
4691 yloc = -kExternalTrayHigh
4692 + kExternalTrayThick + kForwardTrayInterSpace - kExternalTrayThick/2;
4693 cableTrayAExt->AddNode(extTrayAHorFace, 3,
4694 new TGeoTranslation( 0, yloc, zloc));
4695
4696 yloc = -kExternalTrayHigh + kExternalTrayThick + extTrayWall->GetDY();
4697 cableTrayAExt->AddNode(extTrayAWall, 1,
4698 new TGeoTranslation( 0, yloc, zloc));
4699
96eb8210 4700 extCoolTube->AddNode(extCoolFreon, 1, 0);
4701
798b4e0c 4702 yloc = -kExternalTrayHigh + 2*kExternalTrayThick + 2*extTrayWall->GetDY()
4703 + coolTubeExt->GetRmax();
4704 zloc = coolTubeExt->GetDz();
4705 cableTrayAExt->AddNode(extCoolTube, 1,
4706 new TGeoTranslation(0, yloc, zloc));
4707
57126ea1 4708 xloc = optFibsExt->GetZ(1) + coolTubeExt->GetRmax();
798b4e0c 4709 cableTrayAExt->AddNode(extOptFibs, 1,
4710 new TGeoCombiTrans( xloc, 0, 0,
4711 new TGeoRotation("",90,-90,-90)));
4712
57126ea1 4713 xloc = coolTubeExt->GetRmax();
4714 cableTrayAExt->AddNode(extLowCabsCu, 1,
4715 new TGeoCombiTrans(-xloc, 0, 0,
4716 new TGeoRotation("",90,-90,-90)));
4717 cableTrayAExt->AddNode(extLowCabsPUR, 1,
798b4e0c 4718 new TGeoCombiTrans(-xloc, 0, 0,
4719 new TGeoRotation("",90,-90,-90)));
4720
57126ea1 4721 xloc = lowCablesExtCu->GetZ(1) + coolTubeExt->GetRmax();
4722 cableTrayAExt->AddNode(extHiCabsCu, 1,
4723 new TGeoCombiTrans(-xloc, 0, 0,
4724 new TGeoRotation("",90,-90,-90)));
4725 cableTrayAExt->AddNode(extHiCabsPUR, 1,
96eb8210 4726 new TGeoCombiTrans(-xloc, 0, 0,
4727 new TGeoRotation("",90,-90,-90)));
4728
57126ea1 4729 xloc = coaxCablesExtCu->GetZ(1) + optFibsExt->GetZ(1) +
4730 coolTubeExt->GetRmax();
4731 cableTrayAExt->AddNode(extCoaxCu, 1,
4732 new TGeoCombiTrans( xloc, 0, 0,
4733 new TGeoRotation("",90,-90,-90)));
d8826f33 4734 cableTrayAExt->AddNode(extCoaxMeg, 1,
57126ea1 4735 new TGeoCombiTrans( xloc, 0, 0,
4736 new TGeoRotation("",90,-90,-90)));
4737
798b4e0c 4738
4739 // Finally put everything in the mother volume
4740 Double_t rExtTray = kTrayAR2Trans + kExternalTrayHigh;
4741
4742 moth->AddNode(cableTrayAForw,1,
4743 new TGeoTranslation( 0, kTrayAR1Trans, kTrayAZTrans));
4744 moth->AddNode(cableTrayAForw,2,
4745 new TGeoCombiTrans( 0,-kTrayAR1Trans, kTrayAZTrans,
4746 new TGeoRotation("",180, 0, 0)));
4747
4748 yloc = kTrayAR1Trans + kExternalTrayHigh;
4749 zloc = kTrayAZTrans + kForwardTrayTotalLen;
4750 moth->AddNode(cableTrayAExt,1,
4751 new TGeoCombiTrans( 0, yloc, zloc,
4752 new TGeoRotation("", 0,-kTrayAZRot, 0)));
4753 moth->AddNode(cableTrayAExt,2,
4754 new TGeoCombiTrans( 0,-yloc, zloc,
4755 new TGeoRotation("",180,-kTrayAZRot, 0)));
4756
4757 alpharot = kTrayAFirstRotAng + kTrayASecondRotAng;
4758 xloc = kTrayAR2Trans*SinD(alpharot);
4759 yloc = kTrayAR2Trans*CosD(alpharot);
4760 moth->AddNode(cableTrayAForw,3,
4761 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4762 new TGeoRotation("",-alpharot,0,0) ) );
4763 xloc = rExtTray*SinD(alpharot);
4764 yloc = rExtTray*CosD(alpharot);
4765 moth->AddNode(cableTrayAExt,3,
4766 new TGeoCombiTrans( xloc, yloc, zloc,
4767 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4768
4769 alpharot += 180;
4770 xloc = kTrayAR2Trans*SinD(alpharot);
4771 yloc = kTrayAR2Trans*CosD(alpharot);
4772 moth->AddNode(cableTrayAForw,4,
4773 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4774 new TGeoRotation("",-alpharot,0,0) ) );
4775 xloc = rExtTray*SinD(alpharot);
4776 yloc = rExtTray*CosD(alpharot);
4777 moth->AddNode(cableTrayAExt,4,
4778 new TGeoCombiTrans( xloc, yloc, zloc,
4779 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4780
4781 alpharot = - kTrayAFirstRotAng - kTrayASecondRotAng;
4782 xloc = kTrayAR2Trans*SinD(alpharot);
4783 yloc = kTrayAR2Trans*CosD(alpharot);
4784 moth->AddNode(cableTrayAForw,5,
4785 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4786 new TGeoRotation("",-alpharot,0,0) ) );
4787 xloc = rExtTray*SinD(alpharot);
4788 yloc = rExtTray*CosD(alpharot);
4789 moth->AddNode(cableTrayAExt,5,
4790 new TGeoCombiTrans( xloc, yloc, zloc,
4791 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4792
4793 alpharot += 180;
4794 xloc = kTrayAR2Trans*SinD(alpharot);
4795 yloc = kTrayAR2Trans*CosD(alpharot);
4796 moth->AddNode(cableTrayAForw,6,
4797 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4798 new TGeoRotation("",-alpharot,0,0) ) );
4799 xloc = rExtTray*SinD(alpharot);
4800 yloc = rExtTray*CosD(alpharot);
4801 moth->AddNode(cableTrayAExt,6,
4802 new TGeoCombiTrans( xloc, yloc, zloc,
4803 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4804
4805 alpharot = kTrayAFirstRotAng + 3*kTrayASecondRotAng;
4806 xloc = kTrayAR2Trans*SinD(alpharot);
4807 yloc = kTrayAR2Trans*CosD(alpharot);
4808 moth->AddNode(cableTrayAForw,7,
4809 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4810 new TGeoRotation("",-alpharot,0,0) ) );
4811 xloc = rExtTray*SinD(alpharot);
4812 yloc = rExtTray*CosD(alpharot);
4813 moth->AddNode(cableTrayAExt,7,
4814 new TGeoCombiTrans( xloc, yloc, zloc,
4815 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4816
4817 alpharot += 180;
4818 xloc = kTrayAR2Trans*SinD(alpharot);
4819 yloc = kTrayAR2Trans*CosD(alpharot);
4820 moth->AddNode(cableTrayAForw,8,
4821 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4822 new TGeoRotation("",-alpharot,0,0) ) );
4823 xloc = rExtTray*SinD(alpharot);
4824 yloc = rExtTray*CosD(alpharot);
4825 moth->AddNode(cableTrayAExt,8,
4826 new TGeoCombiTrans( xloc, yloc, zloc,
4827 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4828
4829 alpharot = - kTrayAFirstRotAng - 3*kTrayASecondRotAng;
4830 xloc = kTrayAR2Trans*SinD(alpharot);
4831 yloc = kTrayAR2Trans*CosD(alpharot);
4832 moth->AddNode(cableTrayAForw,9,
4833 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4834 new TGeoRotation("",-alpharot,0,0) ) );
4835 xloc = rExtTray*SinD(alpharot);
4836 yloc = rExtTray*CosD(alpharot);
4837 moth->AddNode(cableTrayAExt,9,
4838 new TGeoCombiTrans( xloc, yloc, zloc,
4839 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4840
4841 alpharot += 180;
4842 xloc = kTrayAR2Trans*SinD(alpharot);
4843 yloc = kTrayAR2Trans*CosD(alpharot);
4844 moth->AddNode(cableTrayAForw,10,
4845 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4846 new TGeoRotation("",-alpharot,0,0) ) );
4847 xloc = rExtTray*SinD(alpharot);
4848 yloc = rExtTray*CosD(alpharot);
4849 moth->AddNode(cableTrayAExt,10,
4850 new TGeoCombiTrans( xloc, yloc, zloc,
4851 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4852
4853
4854 return;
4855}
4856
aa177c73 4857//______________________________________________________________________
4858void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
43aefea7 4859 const TGeoManager *mgr){
aa177c73 4860//
4861// Creates the SPD cable trays which are outside the ITS support cones
4862// but still inside the TPC on Side C
4863// (part of this code is taken or anyway inspired to ServicesCableSupport
4864// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
4865//
4866// Input:
4867// moth : the TGeoVolume owing the volume structure
4868// mgr : the GeoManager (default gGeoManager)
4869// Output:
4870//
4871// Return:
4872//
4873// Created: ??? Bjorn S. Nilsen
4874// Updated: 22 Apr 2010 Mario Sitta
96eb8210 4875// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes
57126ea1 4876// Updated: 08 Sep 2010 Mario Sitta
1c5895a3 4877// Updated: 14 Sep 2010 Mario Sitta Cables prolonged till cone
5d9d4033 4878// Updated: 20 Dec 2011 Mario Sitta Composite vol to avoid new overlap
aa177c73 4879//
4880// Technical data are taken from AutoCAD drawings and other (oral)
4881// information given by D.Elia
57126ea1 4882// Optical fibers and voltage cables are approximated with mean materials
4883// and square cross sections, but preserving the total material budget.
aa177c73 4884//
4885
4886 // Dimensions and positions of the C-Side Cable Tray elements
4887 const Int_t kNumTraysSideC = 10;
4888
1c5895a3 4889 const Double_t kTrayCCablesOutRot = 75.000 *fgkDegree;// Computed
4890 const Double_t kTrayCCablesZLenOut = 245.000 *fgkmm;// Computed
4891
aa177c73 4892 const Double_t kTrayCHalfWide = 6.350 *fgkcm;
4893 const Double_t kTrayCLength1 = 172.800 *fgkcm;
4894 const Double_t kTrayCLength2 = 189.300 *fgkcm;
4895 const Double_t kTrayCFirstLen = 435.000 *fgkmm;
4896 const Double_t kTrayCFirstHigh = 83.000 *fgkmm;//!!!TO BE CHECKED!!!
4897 const Double_t kTrayCSecondHigh = 52.700 *fgkmm;//!!!TO BE CHECKED!!!
4898 const Double_t kTrayCThick = 0.200 *fgkcm;
4899 const Double_t kTrayCInterSpace = 18.000 *fgkmm;//!!!TO BE CHECKED!!!
4900 const Double_t kTrayCFoldAngle = 5.000 *fgkDegree;
4901
57126ea1 4902 const Double_t kCoolingTubeRmin = 2.000 *fgkmm;
4903 const Double_t kCoolingTubeRmax = 3.000 *fgkmm;
aa177c73 4904 const Double_t kOpticalFibersSect = 8.696 *fgkmm;//!!!ESTIMATED!!!
57126ea1 4905 const Double_t kLowVoltCableSectCu = 7.675 *fgkmm;// Computed
4906 const Double_t kLowVoltCableHighPUR = 1.000 *fgkmm;// Computed
4907 const Double_t kHiVoltCableSectCu = 1.535 *fgkmm;// Computed
4908 const Double_t kHiVoltCableHighPUR = 0.500 *fgkmm;// Computed
d8826f33 4909 const Double_t kCoaxCableSectCu = 6.024 *fgkmm;// Computed
4910 const Double_t kCoaxCableHighMeg = 5.695 *fgkmm;// Computed
aa177c73 4911
5d9d4033 4912 const Double_t kCablesYtrans = 2.500 *fgkmm;// Avoid ovlps
4913
aa177c73 4914 // Overall position and rotation of the C-Side Cable Trays
4915 const Double_t kTraySideCRPos = 45.300 *fgkcm;
4916 const Double_t kTraySideCZPos = -102.400 *fgkcm;
4917 const Double_t kTraySideCAlphaRot[kNumTraysSideC/2] =
4918 { 0.0, 41.0, -41.0, 76.0, -76.0};
4919 // From position of the other trays
4920
4921
4922 // Local variables
4923 Double_t xprof[8], yprof[8];
4924 Double_t xloc, yloc, zloc, delta, alpharot;
4925
4926
4927 // The single C-Side Cable tray as an assembly
4928 TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly("ITSsupportSPDTrayC");
4929
4930 // First create all needed shapes
4931
4932 // The Cable Tray lower face: a Xtru
4933 TGeoXtru *sideCHorFace = new TGeoXtru(2);
5d9d4033 4934 sideCHorFace->SetName("ITSsuppSPDTraySideCHor");
aa177c73 4935
4936 xprof[0] = 0.;
4937 yprof[0] = 0.;
4938 xprof[1] = kTrayCLength1;
4939 yprof[1] = 0.;
4940 xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
4941 yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
4942 xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle);
4943 yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle);
4944 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4945 kTrayCThick , xprof[4], yprof[4]);
4946 xprof[5] = 0.;
4947 yprof[5] = kTrayCThick;
4948
4949 delta = kTrayCHalfWide - kTrayCThick;
4950
4951 sideCHorFace->DefinePolygon(6, xprof, yprof);
4952 sideCHorFace->DefineSection(0,-delta);
4953 sideCHorFace->DefineSection(1, delta);
4954
4955 // The Cable Tray middle face: a Xtru
4956 // (somehow duplicate of HorFace, but in this way avoid an overlap with Wall)
4957 TGeoXtru *sideCMidFace = new TGeoXtru(2);
4958
4959 xprof[0] = 0.;
4960 yprof[0] = kTrayCInterSpace + kTrayCThick;
4961 xprof[1] = kTrayCLength1;
4962 yprof[1] = yprof[0];
4963 xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
4964 yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
4965 xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle);
4966 yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle);
4967 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4968 kTrayCThick , xprof[4], yprof[4]);
4969 xprof[5] = 0.;
4970 yprof[5] = yprof[0] + kTrayCThick;
4971
4972 delta = kTrayCHalfWide - kTrayCThick;
4973
4974 sideCMidFace->DefinePolygon(6, xprof, yprof);
4975 sideCMidFace->DefineSection(0,-delta);
4976 sideCMidFace->DefineSection(1, delta);
4977
4978 // The Cable Tray lower face: a Xtru
4979 TGeoXtru *sideCSideFace = new TGeoXtru(2);
4980
4981 xprof[0] = 0.;
4982 yprof[0] = 0.;
4983 xprof[1] = kTrayCLength1;
4984 yprof[1] = 0.;
4985 xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
4986 yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
4987 xprof[3] = xprof[2] - kTrayCSecondHigh*SinD(kTrayCFoldAngle);
4988 yprof[3] = yprof[2] + kTrayCSecondHigh*CosD(kTrayCFoldAngle);
4989 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4990 kTrayCSecondHigh , xprof[4], yprof[4]);
4991 xprof[5] = kTrayCFirstLen;
4992 yprof[5] = kTrayCSecondHigh;
4993 xprof[6] = xprof[5];
4994 yprof[6] = kTrayCFirstHigh;
4995 xprof[7] = xprof[0];
4996 yprof[7] = yprof[6];
4997
4998 sideCSideFace->DefinePolygon(8, xprof, yprof);
4999 sideCSideFace->DefineSection(0, 0);
5000 sideCSideFace->DefineSection(1, kTrayCThick);
5001
5002 // The short cover: a BBox
5003 TGeoBBox *sideCShortCover = new TGeoBBox(kTrayCFirstLen/2,
5004 kTrayCThick/2,
5005 kTrayCHalfWide-kTrayCThick);
5006
5007 // The long cover: a Xtru
5008 TGeoXtru *sideCLongCover = new TGeoXtru(2);
5009
5010 xprof[5] = sideCSideFace->GetX(5);
5011 yprof[5] = sideCSideFace->GetY(5);
5012 xprof[4] = sideCSideFace->GetX(4);
5013 yprof[4] = sideCSideFace->GetY(4);
5014 xprof[3] = sideCSideFace->GetX(3);
5015 yprof[3] = sideCSideFace->GetY(3);
5016 xprof[2] = xprof[3] + kTrayCThick*SinD(kTrayCFoldAngle);
5017 yprof[2] = yprof[3] - kTrayCThick*CosD(kTrayCFoldAngle);
5018 InsidePoint(xprof[5], yprof[5], xprof[4], yprof[4], xprof[3], yprof[3],
5019 -kTrayCThick , xprof[1], yprof[1]);
5020 xprof[0] = xprof[5];
5021 yprof[0] = yprof[5] - kTrayCThick;
5022
5023 delta = kTrayCHalfWide - kTrayCThick;
5024
5025 sideCLongCover->DefinePolygon(6, xprof, yprof);
5026 sideCLongCover->DefineSection(0,-delta);
5027 sideCLongCover->DefineSection(1, delta);
5028
5029 // The internal wall: a Xtru
5030 TGeoXtru *intWall = new TGeoXtru(2);
5d9d4033 5031 intWall->SetName("ITSsuppSPDTraySideCWall");
aa177c73 5032
5033 xprof[0] = sideCHorFace->GetX(5);
5034 yprof[0] = sideCHorFace->GetY(5);
5035 xprof[1] = sideCHorFace->GetX(4);
5036 yprof[1] = sideCHorFace->GetY(4);
5037 xprof[2] = sideCHorFace->GetX(3);
5038 yprof[2] = sideCHorFace->GetY(3);
5039 xprof[3] = sideCMidFace->GetX(2);
5040 yprof[3] = sideCMidFace->GetY(2);
5041 xprof[4] = sideCMidFace->GetX(1);
5042 yprof[4] = sideCMidFace->GetY(1);
5043 xprof[5] = sideCMidFace->GetX(0);
5044 yprof[5] = sideCMidFace->GetY(0);
5045
5046 intWall->DefinePolygon(6, xprof, yprof);
5047 intWall->DefineSection(0,-kTrayCThick/2);
5048 intWall->DefineSection(1, kTrayCThick/2);
5049
5050 // The horizontal part of the cooling tube inside the tray: a Tube
5051 delta = sideCMidFace->GetX(4) - sideCMidFace->GetX(5);
96eb8210 5052 TGeoTube *horTube = new TGeoTube(0, kCoolingTubeRmax, delta/2);
5053
5054 // The freon inside the horizontal part of the cooling tube: a Tube
5055 TGeoTube *horFreon = new TGeoTube(0, kCoolingTubeRmin, delta/2);
aa177c73 5056
5057 // The inclined part of the cooling tube inside the tray: a Ctub
5058 Double_t x3, y3, x4, y4;
5059 x3 = sideCMidFace->GetX(3);
5060 y3 = sideCMidFace->GetY(3);
5061 x4 = sideCMidFace->GetX(4);
5062 y4 = sideCMidFace->GetY(4);
5063 delta = TMath::Sqrt( (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
5064 (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle)) +
5065 (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
5066 (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle)) );
5067
96eb8210 5068 TGeoCtub *incTube = new TGeoCtub(0, kCoolingTubeRmax, delta/2, 0, 360,
5069 0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
5070 0, 0, 1);
5071
5072 // The freon inside the inclined part of the cooling tube: a Ctub
5073 TGeoCtub *incFreon = new TGeoCtub(0, kCoolingTubeRmin, delta/2, 0, 360,
aa177c73 5074 0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
5075 0, 0, 1);
5076
1c5895a3 5077 // The part of the cooling tube outside the tray: a Ctub
5078 TGeoCtub *outTube = new TGeoCtub(0, kCoolingTubeRmax,
5079 0.5*kTrayCCablesZLenOut/SinD(kTrayCCablesOutRot),
5080 0, 360,
5081 0, 0, -1,
5082 0,-SinD(kTrayCCablesOutRot), CosD(kTrayCCablesOutRot));
5083
5084 // The freon inside the part of the cooling tube outside the tray: a Ctub
5085 TGeoCtub *outFreon = new TGeoCtub(0, kCoolingTubeRmin,
5086 outTube->GetDz(),
5087 0, 360,
5088 0, 0, -1,
5089 0,-SinD(kTrayCCablesOutRot), CosD(kTrayCCablesOutRot));
5090
aa177c73 5091 // The optical fibers inside the tray: a Xtru
5092 TGeoXtru *optFibs = new TGeoXtru(2);
5093
1c5895a3 5094 xprof[0] = -kTrayCCablesZLenOut;
5095 yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
5096 xprof[1] = sideCMidFace->GetX(5);
5d9d4033 5097 yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
1c5895a3 5098 xprof[2] = sideCMidFace->GetX(4);
5d9d4033 5099 yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
1c5895a3 5100 xprof[3] = sideCMidFace->GetX(3);
5d9d4033 5101 yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
1c5895a3 5102 xprof[4] = xprof[3] - kOpticalFibersSect*SinD(kTrayCFoldAngle);
5103 yprof[4] = yprof[3] + kOpticalFibersSect*CosD(kTrayCFoldAngle);
5104 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
5105 kOpticalFibersSect , xprof[5], yprof[5]);
5106 xprof[6] = 0.;
5107 yprof[6] = yprof[1] + kOpticalFibersSect;
5108 xprof[7] = xprof[0];
5109 yprof[7] = yprof[0] + kOpticalFibersSect;
aa177c73 5110
1c5895a3 5111 optFibs->DefinePolygon(8, xprof, yprof);
aa177c73 5112 optFibs->DefineSection(0, 0);
5113 optFibs->DefineSection(1, kOpticalFibersSect);
5114
57126ea1 5115 // The low voltage cables inside the tray: two Xtru
5116 TGeoXtru *lowCablesCu = new TGeoXtru(2);
5117
1c5895a3 5118 xprof[0] = -kTrayCCablesZLenOut;
5119 yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
5120 xprof[1] = sideCMidFace->GetX(5);
5d9d4033 5121 yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
1c5895a3 5122 xprof[2] = sideCMidFace->GetX(4);
5d9d4033 5123 yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
1c5895a3 5124 xprof[3] = sideCMidFace->GetX(3);
5d9d4033 5125 yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
1c5895a3 5126 xprof[4] = xprof[3] - kLowVoltCableSectCu*SinD(kTrayCFoldAngle);
5127 yprof[4] = yprof[3] + kLowVoltCableSectCu*CosD(kTrayCFoldAngle);
5128 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
5129 kLowVoltCableSectCu , xprof[5], yprof[5]);
5130 xprof[6] = 0.;
5131 yprof[6] = yprof[1] + kLowVoltCableSectCu;
5132 xprof[7] = xprof[0];
5133 yprof[7] = yprof[0] + kLowVoltCableSectCu;
57126ea1 5134
1c5895a3 5135 lowCablesCu->DefinePolygon(8, xprof, yprof);
57126ea1 5136 lowCablesCu->DefineSection(0, 0);
5137 lowCablesCu->DefineSection(1, kLowVoltCableSectCu);
5138
5139 TGeoXtru *lowCablesPUR = new TGeoXtru(2);
5140
1c5895a3 5141 xprof[0] = lowCablesCu->GetX(7);
5142 yprof[0] = lowCablesCu->GetY(7);
5143 xprof[1] = lowCablesCu->GetX(6);
5144 yprof[1] = lowCablesCu->GetY(6);
5145 xprof[2] = lowCablesCu->GetX(5);
5146 yprof[2] = lowCablesCu->GetY(5);
5147 xprof[3] = lowCablesCu->GetX(4);
5148 yprof[3] = lowCablesCu->GetY(4);
5149 xprof[4] = xprof[3] - kLowVoltCableHighPUR*SinD(kTrayCFoldAngle);
5150 yprof[4] = yprof[3] + kLowVoltCableHighPUR*CosD(kTrayCFoldAngle);
5151 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
5152 kLowVoltCableHighPUR , xprof[5], yprof[5]);
5153 xprof[6] = 0.;
5154 yprof[6] = yprof[1] + kLowVoltCableHighPUR;
5155 xprof[7] = xprof[0];
5156 yprof[7] = yprof[0] + kLowVoltCableHighPUR;
57126ea1 5157
1c5895a3 5158 lowCablesPUR->DefinePolygon(8, xprof, yprof);
57126ea1 5159 lowCablesPUR->DefineSection(0, 0);
5160 lowCablesPUR->DefineSection(1, kLowVoltCableSectCu);
5161
5162 // The high voltage cables inside the tray: two Xtru
5163 TGeoXtru *hiCablesCu = new TGeoXtru(2);
aa177c73 5164
1c5895a3 5165 xprof[0] = -kTrayCCablesZLenOut;
5166 yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
5167 xprof[1] = sideCMidFace->GetX(5);
5d9d4033 5168 yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
1c5895a3 5169 xprof[2] = sideCMidFace->GetX(4);
5d9d4033 5170 yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
1c5895a3 5171 xprof[3] = sideCMidFace->GetX(3);
5d9d4033 5172 yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
1c5895a3 5173 xprof[4] = xprof[3] - kHiVoltCableSectCu*SinD(kTrayCFoldAngle);
5174 yprof[4] = yprof[3] + kHiVoltCableSectCu*CosD(kTrayCFoldAngle);
5175 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
5176 kHiVoltCableSectCu , xprof[5], yprof[5]);
5177 xprof[6] = 0.;
5178 yprof[6] = yprof[1] + kHiVoltCableSectCu;
5179 xprof[7] = xprof[0];
5180 yprof[7] = yprof[0] + kHiVoltCableSectCu;
57126ea1 5181
1c5895a3 5182 hiCablesCu->DefinePolygon(8, xprof, yprof);
57126ea1 5183 hiCablesCu->DefineSection(0, 0);
5184 hiCablesCu->DefineSection(1, kHiVoltCableSectCu);
5185
5186 TGeoXtru *hiCablesPUR = new TGeoXtru(2);
5187
1c5895a3 5188 xprof[0] = hiCablesCu->GetX(7);
5189 yprof[0] = hiCablesCu->GetY(7);
5190 xprof[1] = hiCablesCu->GetX(6);
5191 yprof[1] = hiCablesCu->GetY(6);
5192 xprof[2] = hiCablesCu->GetX(5);
5193 yprof[2] = hiCablesCu->GetY(5);
5194 xprof[3] = hiCablesCu->GetX(4);
5195 yprof[3] = hiCablesCu->GetY(4);
5196 xprof[4] = xprof[3] - kHiVoltCableHighPUR*SinD(kTrayCFoldAngle);
5197 yprof[4] = yprof[3] + kHiVoltCableHighPUR*CosD(kTrayCFoldAngle);
5198 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
5199 kHiVoltCableHighPUR , xprof[5], yprof[5]);
5200 xprof[6] = 0.;
5201 yprof[6] = yprof[1] + kHiVoltCableHighPUR;
5202 xprof[7] = xprof[0];
5203 yprof[7] = yprof[0] + kHiVoltCableHighPUR;
aa177c73 5204
1c5895a3 5205 hiCablesPUR->DefinePolygon(8, xprof, yprof);
57126ea1 5206 hiCablesPUR->DefineSection(0, 0);
5207 hiCablesPUR->DefineSection(1, kHiVoltCableSectCu);
aa177c73 5208
57126ea1 5209 // The coaxial cables inside the tray: two Xtru
5210 TGeoXtru *coaxCablesCu = new TGeoXtru(2);
96eb8210 5211
1c5895a3 5212 xprof[0] = -kTrayCCablesZLenOut;
5213 yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
5214 xprof[1] = sideCMidFace->GetX(5);
5d9d4033 5215 yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
1c5895a3 5216 xprof[2] = sideCMidFace->GetX(4);
5d9d4033 5217 yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
1c5895a3 5218 xprof[3] = sideCMidFace->GetX(3);
5d9d4033 5219 yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
1c5895a3 5220 xprof[4] = xprof[3] - kCoaxCableSectCu*SinD(kTrayCFoldAngle);
5221 yprof[4] = yprof[3] + kCoaxCableSectCu*CosD(kTrayCFoldAngle);
5222 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
5223 kCoaxCableSectCu , xprof[5], yprof[5]);
5224 xprof[6] = 0.;
5225 yprof[6] = yprof[1] + kCoaxCableSectCu;
5226 xprof[7] = xprof[0];
5227 yprof[7] = yprof[0] + kCoaxCableSectCu;
57126ea1 5228
1c5895a3 5229 coaxCablesCu->DefinePolygon(8, xprof, yprof);
57126ea1 5230 coaxCablesCu->DefineSection(0, 0);
5231 coaxCablesCu->DefineSection(1, kCoaxCableSectCu);
5232
d8826f33 5233 TGeoXtru *coaxCablesMeg = new TGeoXtru(2);
57126ea1 5234
1c5895a3 5235 xprof[0] = coaxCablesCu->GetX(7);
5236 yprof[0] = coaxCablesCu->GetY(7);
5237 xprof[1] = coaxCablesCu->GetX(6);
5238 yprof[1] = coaxCablesCu->GetY(6);
5239 xprof[2] = coaxCablesCu->GetX(5);
5240 yprof[2] = coaxCablesCu->GetY(5);
5241 xprof[3] = coaxCablesCu->GetX(4);
5242 yprof[3] = coaxCablesCu->GetY(4);
d8826f33 5243 xprof[4] = xprof[3] - kCoaxCableHighMeg*SinD(kTrayCFoldAngle);
5244 yprof[4] = yprof[3] + kCoaxCableHighMeg*CosD(kTrayCFoldAngle);
1c5895a3 5245 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
d8826f33 5246 kCoaxCableHighMeg , xprof[5], yprof[5]);
1c5895a3 5247 xprof[6] = 0.;
d8826f33 5248 yprof[6] = yprof[1] + kCoaxCableHighMeg;
1c5895a3 5249 xprof[7] = xprof[0];
d8826f33 5250 yprof[7] = yprof[0] + kCoaxCableHighMeg;
96eb8210 5251
d8826f33 5252 coaxCablesMeg->DefinePolygon(8, xprof, yprof);
5253 coaxCablesMeg->DefineSection(0, 0);
5254 coaxCablesMeg->DefineSection(1, kCoaxCableSectCu);
96eb8210 5255
5d9d4033 5256 // To avoid a newly discovered overlap,
5257 // transform the two overlapping volumes into a Composite Shape
5258 TGeoCompositeShape *trayIntern =
5259 new TGeoCompositeShape("ITSSPDInternalTrayC",
5260 "ITSsuppSPDTraySideCHor+ITSsuppSPDTraySideCWall");
aa177c73 5261
5262 // We have all shapes: now create the real volumes
0801d201 5263 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
5264 TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$");
96eb8210 5265 TGeoMedium *medFr = mgr->GetMedium("ITS_Freon$");
0801d201 5266 TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!!
5267 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
5268 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
d8826f33 5269 TGeoMedium *medMeg = mgr->GetMedium("ITS_MEGOLON$");
aa177c73 5270
5d9d4033 5271 TGeoVolume *traySideCIntern = new TGeoVolume("ITSsuppSPDTraySideCInternal",
5272 trayIntern, medAl);
aa177c73 5273
5d9d4033 5274 traySideCIntern->SetVisibility(kTRUE);
5275 traySideCIntern->SetLineColor(6); // Purple
5276 traySideCIntern->SetLineWidth(1);
5277 traySideCIntern->SetFillColor(traySideCIntern->GetLineColor());
5278 traySideCIntern->SetFillStyle(4000); // 0% transparent
aa177c73 5279
5280 TGeoVolume *traySideCMidFace = new TGeoVolume("ITSsuppSPDTraySideCMid",
5281 sideCMidFace, medAl);
5282
5283 traySideCMidFace->SetVisibility(kTRUE);
5284 traySideCMidFace->SetLineColor(6); // Purple
5285 traySideCMidFace->SetLineWidth(1);
5286 traySideCMidFace->SetFillColor(traySideCMidFace->GetLineColor());
5287 traySideCMidFace->SetFillStyle(4000); // 0% transparent
5288
5289 TGeoVolume *traySideCSideFace = new TGeoVolume("ITSsuppSPDTraySideCSide",
5290 sideCSideFace, medAl);
5291
5292 traySideCSideFace->SetVisibility(kTRUE);
5293 traySideCSideFace->SetLineColor(6); // Purple
5294 traySideCSideFace->SetLineWidth(1);
5295 traySideCSideFace->SetFillColor(traySideCSideFace->GetLineColor());
5296 traySideCSideFace->SetFillStyle(4000); // 0% transparent
5297
5298 TGeoVolume *traySideCShortCover = new TGeoVolume("ITSsuppSPDTraySideCShCov",
5299 sideCShortCover, medAl);
5300
5301 traySideCShortCover->SetVisibility(kTRUE);
5302 traySideCShortCover->SetLineColor(6); // Purple
5303 traySideCShortCover->SetLineWidth(1);
5304 traySideCShortCover->SetFillColor(traySideCShortCover->GetLineColor());
5305 traySideCShortCover->SetFillStyle(4000); // 0% transparent
5306
5307 TGeoVolume *traySideCLongCover = new TGeoVolume("ITSsuppSPDTraySideCLnCov",
5308 sideCLongCover, medAl);
5309
5310 traySideCLongCover->SetVisibility(kTRUE);
5311 traySideCLongCover->SetLineColor(6); // Purple
5312 traySideCLongCover->SetLineWidth(1);
5313 traySideCLongCover->SetFillColor(traySideCLongCover->GetLineColor());
5314 traySideCLongCover->SetFillStyle(4000); // 0% transparent
5315
aa177c73 5316 TGeoVolume *traySideCHorTube = new TGeoVolume("ITSsuppSPDTraySideCHorTube",
5317 horTube, medIn);
5318
5319 traySideCHorTube->SetVisibility(kTRUE);
5320 traySideCHorTube->SetLineColor(kGray); // as in GeometrySPD
5321 traySideCHorTube->SetLineWidth(1);
5322 traySideCHorTube->SetFillColor(traySideCHorTube->GetLineColor());
5323 traySideCHorTube->SetFillStyle(4000); // 0% transparent
5324
96eb8210 5325 TGeoVolume *traySideCHorFreon = new TGeoVolume("ITSsuppSPDTraySideCHorFreon",
5326 horFreon, medFr);
5327
5328 traySideCHorFreon->SetVisibility(kTRUE);
5329 traySideCHorFreon->SetLineColor(kBlue); // Blue
5330 traySideCHorFreon->SetLineWidth(1);
5331 traySideCHorFreon->SetFillColor(traySideCHorFreon->GetLineColor());
5332 traySideCHorFreon->SetFillStyle(4000); // 0% transparent
5333
aa177c73 5334 TGeoVolume *traySideCIncTube = new TGeoVolume("ITSsuppSPDTraySideCIncTube",
5335 incTube, medIn);
5336
5337 traySideCIncTube->SetVisibility(kTRUE);
5338 traySideCIncTube->SetLineColor(kGray); // as in GeometrySPD
5339 traySideCIncTube->SetLineWidth(1);
5340 traySideCIncTube->SetFillColor(traySideCIncTube->GetLineColor());
5341 traySideCIncTube->SetFillStyle(4000); // 0% transparent
5342
96eb8210 5343 TGeoVolume *traySideCIncFreon = new TGeoVolume("ITSsuppSPDTraySideCIncFreon",
5344 incFreon, medFr);
5345
5346 traySideCIncFreon->SetVisibility(kTRUE);
5347 traySideCIncFreon->SetLineColor(kBlue); // Blue
5348 traySideCIncFreon->SetLineWidth(1);
5349 traySideCIncFreon->SetFillColor(traySideCIncFreon->GetLineColor());
5350 traySideCIncFreon->SetFillStyle(4000); // 0% transparent
5351
1c5895a3 5352 TGeoVolume *traySideCOutTube = new TGeoVolume("ITSsuppSPDTraySideCOutTube",
5353 outTube, medIn);
5354
5355 traySideCOutTube->SetVisibility(kTRUE);
5356 traySideCOutTube->SetLineColor(kGray); // as in GeometrySPD
5357 traySideCOutTube->SetLineWidth(1);
5358 traySideCOutTube->SetFillColor(traySideCOutTube->GetLineColor());
5359 traySideCOutTube->SetFillStyle(4000); // 0% transparent
5360
5361 TGeoVolume *traySideCOutFreon = new TGeoVolume("ITSsuppSPDTraySideCOutFreon",
5362 outFreon, medFr);
5363
5364 traySideCOutFreon->SetVisibility(kTRUE);
5365 traySideCOutFreon->SetLineColor(kBlue); // Blue
5366 traySideCOutFreon->SetLineWidth(1);
5367 traySideCOutFreon->SetFillColor(traySideCOutFreon->GetLineColor());
5368 traySideCOutFreon->SetFillStyle(4000); // 0% transparent
5369
aa177c73 5370 TGeoVolume *traySideCOptFibs = new TGeoVolume("ITSsuppSPDTraySideCOptFibs",
5371 optFibs, medFibs);
5372
5373 traySideCOptFibs->SetVisibility(kTRUE);
5374 traySideCOptFibs->SetLineColor(kOrange); // Orange
5375 traySideCOptFibs->SetLineWidth(1);
5376 traySideCOptFibs->SetFillColor(traySideCOptFibs->GetLineColor());
5377 traySideCOptFibs->SetFillStyle(4000); // 0% transparent
5378
57126ea1 5379 TGeoVolume *traySideCLowCabsCu = new TGeoVolume("ITSsuppSPDTraySideCLVCu",
5380 lowCablesCu, medCu);
5381
5382 traySideCLowCabsCu->SetVisibility(kTRUE);
5383 traySideCLowCabsCu->SetLineColor(kRed); // Red
5384 traySideCLowCabsCu->SetLineWidth(1);
5385 traySideCLowCabsCu->SetFillColor(traySideCLowCabsCu->GetLineColor());
5386 traySideCLowCabsCu->SetFillStyle(4000); // 0% transparent
5387
5388 TGeoVolume *traySideCLowCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCLVPUR",
5389 lowCablesPUR, medPUR);
5390
5391 traySideCLowCabsPUR->SetVisibility(kTRUE);
5392 traySideCLowCabsPUR->SetLineColor(kBlack); // Black
5393 traySideCLowCabsPUR->SetLineWidth(1);
5394 traySideCLowCabsPUR->SetFillColor(traySideCLowCabsPUR->GetLineColor());
5395 traySideCLowCabsPUR->SetFillStyle(4000); // 0% transparent
aa177c73 5396
57126ea1 5397 TGeoVolume *traySideCHiCabsCu = new TGeoVolume("ITSsuppSPDTraySideCHVCu",
5398 hiCablesCu, medCu);
aa177c73 5399
57126ea1 5400 traySideCHiCabsCu->SetVisibility(kTRUE);
5401 traySideCHiCabsCu->SetLineColor(kRed); // Red
5402 traySideCHiCabsCu->SetLineWidth(1);
5403 traySideCHiCabsCu->SetFillColor(traySideCHiCabsCu->GetLineColor());
5404 traySideCHiCabsCu->SetFillStyle(4000); // 0% transparent
96eb8210 5405
57126ea1 5406 TGeoVolume *traySideCHiCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCHVPUR",
5407 hiCablesPUR, medPUR);
5408
5409 traySideCHiCabsPUR->SetVisibility(kTRUE);
5410 traySideCHiCabsPUR->SetLineColor(kBlack); // Black
5411 traySideCHiCabsPUR->SetLineWidth(1);
5412 traySideCHiCabsPUR->SetFillColor(traySideCHiCabsPUR->GetLineColor());
5413 traySideCHiCabsPUR->SetFillStyle(4000); // 0% transparent
5414
5415 TGeoVolume *traySideCCoaxCu = new TGeoVolume("ITSsuppSPDTraySideCCoaxCu",
5416 coaxCablesCu, medCu);
5417
5418 traySideCCoaxCu->SetVisibility(kTRUE);
5419 traySideCCoaxCu->SetLineColor(kRed); // Red
5420 traySideCCoaxCu->SetLineWidth(1);
5421 traySideCCoaxCu->SetFillColor(traySideCCoaxCu->GetLineColor());
5422 traySideCCoaxCu->SetFillStyle(4000); // 0% transparent
5423
d8826f33 5424 TGeoVolume *traySideCCoaxMeg = new TGeoVolume("ITSsuppSPDTraySideCCoaxMeg",
5425 coaxCablesMeg, medMeg);
57126ea1 5426
d8826f33 5427 traySideCCoaxMeg->SetVisibility(kTRUE);
5428 traySideCCoaxMeg->SetLineColor(kBlack); // Black
5429 traySideCCoaxMeg->SetLineWidth(1);
5430 traySideCCoaxMeg->SetFillColor(traySideCCoaxMeg->GetLineColor());
5431 traySideCCoaxMeg->SetFillStyle(4000); // 0% transparent
96eb8210 5432
aa177c73 5433
5434 // Now build up the trays
5d9d4033 5435 cableTrayC->AddNode(traySideCIntern,1,0);
aa177c73 5436
5437 cableTrayC->AddNode(traySideCMidFace,1,0);
5438
5439 zloc = kTrayCHalfWide - kTrayCThick;
5440 cableTrayC->AddNode(traySideCSideFace, 1,
5441 new TGeoTranslation( 0, 0, zloc));
5442 zloc = -kTrayCHalfWide;
5443 cableTrayC->AddNode(traySideCSideFace, 2,
5444 new TGeoTranslation( 0, 0, zloc));
5445
5446 xloc = sideCShortCover->GetDX();
5447 yloc = kTrayCFirstHigh - sideCShortCover->GetDY();
5448 cableTrayC->AddNode(traySideCShortCover, 1,
5449 new TGeoTranslation( xloc, yloc, 0));
5450
5451 cableTrayC->AddNode(traySideCLongCover,1,0);
5452
96eb8210 5453 traySideCHorTube->AddNode(traySideCHorFreon, 1, 0);
5454 traySideCIncTube->AddNode(traySideCIncFreon, 1, 0);
1c5895a3 5455 traySideCOutTube->AddNode(traySideCOutFreon, 1, 0);
96eb8210 5456
aa177c73 5457 xloc = horTube->GetDz();
5458 yloc = sideCMidFace->GetY(5) + horTube->GetRmax();
5459 cableTrayC->AddNode(traySideCHorTube, 1,
5460 new TGeoCombiTrans( xloc, yloc, 0,
5461 new TGeoRotation("",-90.,-90.,90.)));
5462
5463 xloc = sideCMidFace->GetX(4) + (incTube->GetDz())*CosD(kTrayCFoldAngle);
5464 yloc = sideCMidFace->GetY(4) + incTube->GetRmax() +
5465 (incTube->GetDz())*SinD(kTrayCFoldAngle)+0.005;//Avoid small ovrlp
5466 cableTrayC->AddNode(traySideCIncTube, 1,
5467 new TGeoCombiTrans( xloc, yloc, 0,
5468 new TGeoRotation("",-90.+kTrayCFoldAngle,-90.,90.)));
5469
1c5895a3 5470 xloc = -kTrayCCablesZLenOut/2 - outTube->GetRmax();
5471 yloc = xloc/TanD(kTrayCCablesOutRot) + sideCMidFace->GetY(4) -
5472 2*outTube->GetRmax();
5473 cableTrayC->AddNode(traySideCOutTube, 1,
5474 new TGeoCombiTrans( xloc, yloc, 0,
5475 new TGeoRotation("",-70.,-90.,90.)));
5476
aa177c73 5477 zloc = horTube->GetRmax();
5478 cableTrayC->AddNode(traySideCOptFibs, 1,
5479 new TGeoTranslation( 0, 0, zloc));
5480
57126ea1 5481 zloc = kLowVoltCableSectCu + horTube->GetRmax();
5482 cableTrayC->AddNode(traySideCLowCabsCu, 1,
5483 new TGeoTranslation( 0, 0,-zloc));
5484 cableTrayC->AddNode(traySideCLowCabsPUR, 1,
aa177c73 5485 new TGeoTranslation( 0, 0,-zloc));
5486
57126ea1 5487 zloc = kHiVoltCableSectCu + kLowVoltCableSectCu + horTube->GetRmax();
5488 cableTrayC->AddNode(traySideCHiCabsCu, 1,
5489 new TGeoTranslation( 0, 0,-zloc));
5490 cableTrayC->AddNode(traySideCHiCabsPUR, 1,
96eb8210 5491 new TGeoTranslation( 0, 0,-zloc));
5492
57126ea1 5493 zloc = kOpticalFibersSect + kCoaxCableSectCu + horTube->GetRmax();
5494 cableTrayC->AddNode(traySideCCoaxCu, 1,
5495 new TGeoTranslation( 0, 0, zloc));
d8826f33 5496 cableTrayC->AddNode(traySideCCoaxMeg, 1,
57126ea1 5497 new TGeoTranslation( 0, 0, zloc));
5498
aa177c73 5499
5500 // Finally put everything in the mother volume
5501 for (Int_t jt = 0; jt < kNumTraysSideC/2; jt++) {
5502 alpharot = kTraySideCAlphaRot[jt];
5503
5504 xloc = kTraySideCRPos*SinD(alpharot);
5505 yloc = kTraySideCRPos*CosD(alpharot);
5506 moth->AddNode(cableTrayC,2*jt+1,
5507 new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
5508 new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle)));
5509 alpharot += 180;
5510 xloc = kTraySideCRPos*SinD(alpharot);
5511 yloc = kTraySideCRPos*CosD(alpharot);
5512 moth->AddNode(cableTrayC,2*jt+2,
5513 new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
5514 new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle)));
5515 }
5516
5517
5518 return;
5519}
5520
798b4e0c 5521//______________________________________________________________________
5522void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
f510fd70 5523 const TGeoManager *mgr){
798b4e0c 5524//
5525// Creates the SDD cable trays which are outside the ITS support cones
5526// but still inside the TPC on Side A
5527// (part of this code is taken or anyway inspired to ServicesCableSupport
5528// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
5529//
5530// Input:
5531// moth : the TGeoVolume owing the volume structure
5532// mgr : the GeoManager (default gGeoManager)
5533// Output:
5534//
5535// Created: ??? Bjorn S. Nilsen
5536// Updated: 5 Jan 2010 Mario Sitta
5537// Updated: 26 Feb 2010 Mario Sitta
57126ea1 5538// Updated: 06 Sep 2010 Mario Sitta
798b4e0c 5539//
5540// Technical data are taken from AutoCAD drawings, L.Simonetti technical
5541// drawings and other (oral) information given by F.Tosello
5542//
5543
5544 // Overall position and rotation of the A-Side Cable Trays
5545 // (parts of 0872/G/D)
573a206f 5546 const Double_t kTrayARTrans = 408.35 *fgkmm;
798b4e0c 5547 const Double_t kTrayAZTrans = 1011.00 *fgkmm;
5548 const Double_t kTrayAZToSupportRing = 435.00 *fgkmm;
57126ea1 5549 const Double_t kExternTrayYTrans = 96.00 *fgkmm; // Computed
5550 const Double_t kExternTrayZTrans = 823.00 *fgkmm;
798b4e0c 5551 const Double_t kExternCoverYTrans = 2.00 *fgkmm;
5552 const Double_t kTrayAZRot = (180-169.5);// Degrees
5553 const Double_t kTrayAFirstRotAng = 22.00; // Degrees
5554 const Double_t kTrayASecondRotAng = 15.00; // Degrees
5555
57126ea1 5556 const Double_t kForwardTrayThick = 2.00 *fgkmm;
798b4e0c 5557 const Double_t kForwardTrayTailHeight = 100.00 *fgkmm; // Computed
5558 const Double_t kForwardTrayTotalHeight = 170.00 *fgkmm; // Computed
5559 const Double_t kForwardTrayUpperLength = 405.00 *fgkmm; // Computed
5560 const Double_t kForwardCoverLength = 380.00 *fgkmm;
5561 const Double_t kForwardCoverWide = 133.00 *fgkmm;
5562 const Double_t kForwardCoverHeight = 10.00 *fgkmm;
5563 const Double_t kForwardCoverThick = 1.00 *fgkmm;
5564
5565 const Double_t kExternTrayTotalLen = 1200.00 *fgkmm;
5566 const Double_t kExternTrayTotalHeight = 52.00 *fgkmm;
5567 const Double_t kExternCoverLen = kExternTrayTotalLen;
5568 const Double_t kExternCoverThick = 5.00 *fgkmm;
5569 const Double_t kExternCoverSideThick = 3.00 *fgkmm;
5570
5571 const Int_t kForwardTrayNpoints = 8;
5572
57126ea1 5573 // Dimensions and positions of the Cable Tray elements
5574 const Double_t kSideACoolManifWide = 8.23 *fgkcm;
5575 const Double_t kSideACoolManifHigh = 8.06 *fgkcm;
5576 const Double_t kSideACoolManifLen = 3.90 *fgkcm;
5577 const Double_t kSideACoolManifPOMFrac = 0.0054;
5578 const Double_t kSideACoolManifSteelFrac= 0.8850;
5579 const Double_t kSideACoolManifWaterFrac= 0.0913;
5580 const Double_t kSideACoolManifAlFrac = 0.0183;
5581
5582 const Double_t kSideACoolTubesWide = 9.07 *fgkcm;
5583 const Double_t kSideACoolTubesHigh = 1.88 *fgkcm;
5584 const Double_t kSideACoolTubesTrans = 0.88 *fgkcm;
5585 const Double_t kSideACoolTubesPURFrac = 0.5897;
5586 const Double_t kSideACoolTubesWaterFrac= 0.4101;
5587 const Double_t kSideACoolTubesAirFrac = 0.0002;
5588
5589 const Double_t kSideAOptConnWide = 0.90 *fgkcm;
5590 const Double_t kSideAOptConnLen = 1.37 *fgkcm;
5591 const Double_t kSideAOptConnPBTFrac = 0.5010;
5592 const Double_t kSideAOptConnSteelFrac = 0.1784;
5593 const Double_t kSideAOptConnAlFrac = 0.3206;
5594
5595 const Double_t kSideAOptFibsWide = 0.71 *fgkcm;
5596 const Double_t kSideAOptFibsHigh = 3.20 *fgkcm;
5597
5598 const Double_t kSideAInputCablesWide = 12.50 *fgkcm;
5599 const Double_t kSideAInputCablesHigh = 1.24 *fgkcm;
5600 const Double_t kSideAInputCablesLen = 25.20 *fgkcm;
5601 const Double_t kSideAInputCablesYTrans = 1.15 *fgkcm;
5602 const Double_t kSideAInputCablesCu = 0.7404;
5603 const Double_t kSideAInputCablesPlast = 0.1269;
5604 const Double_t kSideAInputCablesAl = 0.0057;
5605 const Double_t kSideAInputCablesKapton = 0.0172;
5606 const Double_t kSideAInputCablesPOLYAX = 0.1098;
5607
5608 const Double_t kSideAOutputCablesWide = 8.30 *fgkcm;
5609 const Double_t kSideAOutputCablesHigh = 1.56 *fgkcm;
5610 const Double_t kSideAOutputCablesCu = 0.6783;
5611 const Double_t kSideAOutputCablesPlast = 0.1605;
5612 const Double_t kSideAOutputCablesAl = 0.0078;
5613 const Double_t kSideAOutputCablesKapton= 0.0232;
5614 const Double_t kSideAOutputCablesPOLYAX= 0.1302;
5615
5616 const Double_t kSideAPCBBoardsWide = 12.50 *fgkcm;
5617 const Double_t kSideAPCBBoardsHigh = 6.32 *fgkcm;
5618 const Double_t kSideAPCBBoardsLen = 24.00 *fgkcm;
5619 const Double_t kSideAPCBBoardsYTrans = 0.75 *fgkcm;
5620 const Double_t kSideAPCBBoardsCu = 0.3864;
5621 const Double_t kSideAPCBBoardsEpoxy = 0.1486;
5622 const Double_t kSideAPCBBoardsPlast = 0.0578;
5623 const Double_t kSideAPCBBoardsSteel = 0.1521;
5624 const Double_t kSideAPCBBoardsPPS = 0.2551;
5625
798b4e0c 5626
5627 // Local variables
5628 Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
57126ea1 5629 Double_t xloc, yloc, zloc, alpharot, height;
798b4e0c 5630
5631
5632 // The whole tray as an assembly
5633 TGeoVolumeAssembly *cableTrayA = new TGeoVolumeAssembly("ITSsupportSDDTrayA");
5634
5635
5636 // First create all needed shapes
5637
5638 // The forward tray is very complex and deserves a dedicated method
57126ea1 5639 CreateSDDForwardTraySideA(cableTrayA,mgr);
798b4e0c 5640
5641 // The forward cover: a Xtru
5642 TGeoXtru *forwardCover = new TGeoXtru(2);
5643 forwardCover->SetName("ITSsuppSDDForwCover");
5644
5645 xprof[0] = kForwardCoverWide/2;
5646 yprof[0] = kForwardCoverHeight;
5647 xprof[1] = xprof[0];
5648 yprof[1] = 0;
5649 xprof[2] = xprof[1] - kForwardCoverThick;
5650 yprof[2] = yprof[1];
5651 xprof[3] = xprof[2];
5652 yprof[3] = yprof[0] - kForwardCoverThick;
5653
5654 // We did the right side, now reflex on the left side
5655 for (Int_t jp = 0; jp < 4; jp++) {
5656 xprof[4+jp] = -xprof[3-jp];
5657 yprof[4+jp] = yprof[3-jp];
5658 }
5659
5660 forwardCover->DefinePolygon(8, xprof, yprof);
5661 forwardCover->DefineSection(0, 0);
5662 forwardCover->DefineSection(1, kForwardCoverLength);
5663
5664 // The external tray (as 0872/G/D/03): a Xtru
5665 TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternTrayTotalLen,
5666 kExternTrayTotalHeight);
5667
5668 // The external covers: a Composite Shape
5669 TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternCoverLen);
5670
57126ea1 5671 // Now the volumes inside it
5672 // The cooling manifold: four boxes
5673 TGeoBBox *coolManifPOM = new TGeoBBox(kSideACoolManifWide/2,
5674 kSideACoolManifPOMFrac*kSideACoolManifHigh/2,
5675 kSideACoolManifLen/2);
5676
5677 TGeoBBox *coolManifSteel = new TGeoBBox(kSideACoolManifWide/2,
5678 kSideACoolManifSteelFrac*kSideACoolManifHigh/2,
5679 kSideACoolManifLen/2);
5680
5681 TGeoBBox *coolManifWater = new TGeoBBox(kSideACoolManifWide/2,
5682 kSideACoolManifWaterFrac*kSideACoolManifHigh/2,
5683 kSideACoolManifLen/2);
5684
5685 TGeoBBox *coolManifAl = new TGeoBBox(kSideACoolManifWide/2,
5686 kSideACoolManifAlFrac*kSideACoolManifHigh/2,
5687 kSideACoolManifLen/2);
5688
5689 // The cooling tubes: three Xtru's
5690 TGeoXtru *coolTubesPUR = new TGeoXtru(2);
5691
5692 height = kSideACoolTubesHigh*kSideACoolTubesPURFrac;
5693
5694 xprof[0] = kSideACoolManifLen;
5695 yprof[0] = kForwardTrayThick + kSideACoolTubesTrans;
5696 xprof[2] = kExternTrayZTrans + kForwardTrayTotalHeight*SinD(kTrayAZRot) +
5697 kExternTrayTotalLen*CosD(kTrayAZRot) - xprof[0]/2;
5698 yprof[2] = kForwardTrayTotalHeight*(1 - CosD(kTrayAZRot)) +
5699 kExternTrayYTrans - kExternTrayTotalHeight*CosD(kTrayAZRot) +
5700 kExternTrayTotalLen*SinD(kTrayAZRot) + yprof[0];
5701 IntersectLines( 0 , xprof[0], yprof[0],
5702 TanD(kTrayAZRot), xprof[2], yprof[2],
5703 xprof[1], yprof[1]);
5704 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5705 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5706 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5707 height, xprof[4], yprof[4]);
5708 xprof[5] = xprof[0];
5709 yprof[5] = yprof[0] + height;
5710
5711 coolTubesPUR->DefinePolygon(6, xprof, yprof);
5712 coolTubesPUR->DefineSection(0,-kSideACoolTubesWide/2);
5713 coolTubesPUR->DefineSection(1, kSideACoolTubesWide/2);
5714
5715 TGeoXtru *coolTubesWater = new TGeoXtru(2);
5716
5717 height = kSideACoolTubesHigh*kSideACoolTubesWaterFrac;
5718
5719 xprof[0] = coolTubesPUR->GetX(5);
5720 yprof[0] = coolTubesPUR->GetY(5);
5721 xprof[1] = coolTubesPUR->GetX(4);
5722 yprof[1] = coolTubesPUR->GetY(4);
5723 xprof[2] = coolTubesPUR->GetX(3);
5724 yprof[2] = coolTubesPUR->GetY(3);
5725 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5726 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5727 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5728 height, xprof[4], yprof[4]);
5729 xprof[5] = xprof[0];
5730 yprof[5] = yprof[0] + height;
5731
5732 coolTubesWater->DefinePolygon(6, xprof, yprof);
5733 coolTubesWater->DefineSection(0,-kSideACoolTubesWide/2);
5734 coolTubesWater->DefineSection(1, kSideACoolTubesWide/2);
5735
5736 TGeoXtru *coolTubesAir = new TGeoXtru(2);
5737
5738 height = kSideACoolTubesHigh*kSideACoolTubesAirFrac;
5739
5740 xprof[0] = coolTubesWater->GetX(5);
5741 yprof[0] = coolTubesWater->GetY(5);
5742 xprof[1] = coolTubesWater->GetX(4);
5743 yprof[1] = coolTubesWater->GetY(4);
5744 xprof[2] = coolTubesWater->GetX(3);
5745 yprof[2] = coolTubesWater->GetY(3);
5746 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5747 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5748 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5749 height, xprof[4], yprof[4]);
5750 xprof[5] = xprof[0];
5751 yprof[5] = yprof[0] + height;
5752
5753 coolTubesAir->DefinePolygon(6, xprof, yprof);
5754 coolTubesAir->DefineSection(0,-kSideACoolTubesWide/2);
5755 coolTubesAir->DefineSection(1, kSideACoolTubesWide/2);
5756
5757 // The optical fiber connectors: three boxes
5758 TGeoBBox *optConnPBT = new TGeoBBox(kSideAOptConnWide/2,
5759 kSideAOptConnPBTFrac*kSideACoolManifHigh/2,
5760 kSideAOptConnLen/2);
5761
5762 TGeoBBox *optConnSteel = new TGeoBBox(kSideAOptConnWide/2,
5763 kSideAOptConnSteelFrac*kSideACoolManifHigh/2,
5764 kSideAOptConnLen/2);
5765
5766 TGeoBBox *optConnAl = new TGeoBBox(kSideAOptConnWide/2,
5767 kSideAOptConnAlFrac*kSideACoolManifHigh/2,
5768 kSideAOptConnLen/2);
5769
5770 // The optical fibers: a Xtru
5771 TGeoXtru *opticalFibs = new TGeoXtru(2);
5772
5773 xprof[0] = kSideAOptConnLen;
5774 yprof[0] = coolTubesPUR->GetY(0);
5775 xprof[1] = coolTubesPUR->GetX(1);
5776 yprof[1] = coolTubesPUR->GetY(1);
5777 xprof[2] = coolTubesPUR->GetX(2);
5778 yprof[2] = coolTubesPUR->GetY(2);
5779 xprof[3] = xprof[2] - kSideAOptFibsHigh*SinD(kTrayAZRot);
5780 yprof[3] = yprof[2] + kSideAOptFibsHigh*CosD(kTrayAZRot);
5781 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5782 kSideAOptFibsHigh, xprof[4], yprof[4]);
5783 xprof[5] = xprof[0];
5784 yprof[5] = yprof[0] + kSideAOptFibsHigh;
5785
5786 opticalFibs->DefinePolygon(6, xprof, yprof);
5787 opticalFibs->DefineSection(0,-kSideAOptFibsWide/2);
5788 opticalFibs->DefineSection(1, kSideAOptFibsWide/2);
5789
5790 // The input cables: five boxes
5791 TGeoBBox *inputCabsCu = new TGeoBBox(kSideAInputCablesWide/2,
5792 kSideAInputCablesCu*kSideAInputCablesHigh/2,
5793 kSideAInputCablesLen/2);
5794
5795 TGeoBBox *inputCabsPlast = new TGeoBBox(kSideAInputCablesWide/2,
5796 kSideAInputCablesPlast*kSideAInputCablesHigh/2,
5797 kSideAInputCablesLen/2);
5798
5799 TGeoBBox *inputCabsAl = new TGeoBBox(kSideAInputCablesWide/2,
5800 kSideAInputCablesAl*kSideAInputCablesHigh/2,
5801 kSideAInputCablesLen/2);
5802
5803 TGeoBBox *inputCabsKapton = new TGeoBBox(kSideAInputCablesWide/2,
5804 kSideAInputCablesKapton*kSideAInputCablesHigh/2,
5805 kSideAInputCablesLen/2);
5806
5807 TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideAInputCablesWide/2,
5808 kSideAInputCablesPOLYAX*kSideAInputCablesHigh/2,
5809 kSideAInputCablesLen/2);
5810
5811 // The output cables: five Xtru
5812 TGeoXtru *outputCabsCu = new TGeoXtru(2);
5813
5814 height = kSideAOutputCablesCu*kSideAOutputCablesHigh;
5815
5816 xprof[0] = kSideAInputCablesLen/2 + kSideAPCBBoardsLen/2;
5817 yprof[0] = coolTubesAir->GetY(5);
5818 xprof[1] = coolTubesAir->GetX(4);
5819 yprof[1] = coolTubesAir->GetY(4);
5820 xprof[2] = coolTubesAir->GetX(3);
5821 yprof[2] = coolTubesAir->GetY(3);
5822 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5823 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5824 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5825 height, xprof[4], yprof[4]);
5826 xprof[5] = xprof[0];
5827 yprof[5] = yprof[0] + height;
5828
5829 outputCabsCu->DefinePolygon(6, xprof, yprof);
5830 outputCabsCu->DefineSection(0,-kSideAOutputCablesWide/2);
5831 outputCabsCu->DefineSection(1, kSideAOutputCablesWide/2);
5832
5833 TGeoXtru *outputCabsPlast = new TGeoXtru(2);
5834
5835 height = kSideAOutputCablesPlast*kSideAOutputCablesHigh;
5836
5837 xprof[0] = outputCabsCu->GetX(5);
5838 yprof[0] = outputCabsCu->GetY(5);
5839 xprof[1] = outputCabsCu->GetX(4);
5840 yprof[1] = outputCabsCu->GetY(4);
5841 xprof[2] = outputCabsCu->GetX(3);
5842 yprof[2] = outputCabsCu->GetY(3);
5843 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5844 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5845 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5846 height, xprof[4], yprof[4]);
5847 xprof[5] = xprof[0];
5848 yprof[5] = yprof[0] + height;
5849
5850 outputCabsPlast->DefinePolygon(6, xprof, yprof);
5851 outputCabsPlast->DefineSection(0,-kSideAOutputCablesWide/2);
5852 outputCabsPlast->DefineSection(1, kSideAOutputCablesWide/2);
5853
5854 TGeoXtru *outputCabsAl = new TGeoXtru(2);
5855
5856 height = kSideAOutputCablesAl*kSideAOutputCablesHigh;
5857
5858 xprof[0] = outputCabsPlast->GetX(5);
5859 yprof[0] = outputCabsPlast->GetY(5);
5860 xprof[1] = outputCabsPlast->GetX(4);
5861 yprof[1] = outputCabsPlast->GetY(4);
5862 xprof[2] = outputCabsPlast->GetX(3);
5863 yprof[2] = outputCabsPlast->GetY(3);
5864 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5865 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5866 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5867 height, xprof[4], yprof[4]);
5868 xprof[5] = xprof[0];
5869 yprof[5] = yprof[0] + height;
5870
5871 outputCabsAl->DefinePolygon(6, xprof, yprof);
5872 outputCabsAl->DefineSection(0,-kSideAOutputCablesWide/2);
5873 outputCabsAl->DefineSection(1, kSideAOutputCablesWide/2);
5874
5875 TGeoXtru *outputCabsKapton = new TGeoXtru(2);
5876
5877 height = kSideAOutputCablesKapton*kSideAOutputCablesHigh;
5878
5879 xprof[0] = outputCabsAl->GetX(5);
5880 yprof[0] = outputCabsAl->GetY(5);
5881 xprof[1] = outputCabsAl->GetX(4);
5882 yprof[1] = outputCabsAl->GetY(4);
5883 xprof[2] = outputCabsAl->GetX(3);
5884 yprof[2] = outputCabsAl->GetY(3);
5885 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5886 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5887 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5888 height, xprof[4], yprof[4]);
5889 xprof[5] = xprof[0];
5890 yprof[5] = yprof[0] + height;
5891
5892 outputCabsKapton->DefinePolygon(6, xprof, yprof);
5893 outputCabsKapton->DefineSection(0,-kSideAOutputCablesWide/2);
5894 outputCabsKapton->DefineSection(1, kSideAOutputCablesWide/2);
5895
5896 TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
5897
5898 height = kSideAOutputCablesPOLYAX*kSideAOutputCablesHigh;
5899
5900 xprof[0] = outputCabsKapton->GetX(5);
5901 yprof[0] = outputCabsKapton->GetY(5);
5902 xprof[1] = outputCabsKapton->GetX(4);
5903 yprof[1] = outputCabsKapton->GetY(4);
5904 xprof[2] = outputCabsKapton->GetX(3);
5905 yprof[2] = outputCabsKapton->GetY(3);
5906 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5907 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5908 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5909 height, xprof[4], yprof[4]);
5910 xprof[5] = xprof[0];
5911 yprof[5] = yprof[0] + height;
5912
5913 outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
5914 outputCabsPOLYAX->DefineSection(0,-kSideAOutputCablesWide/2);
5915 outputCabsPOLYAX->DefineSection(1, kSideAOutputCablesWide/2);
5916
5917 // The PCB boards: five boxes
5918 TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideAPCBBoardsWide/2,
5919 kSideAPCBBoardsCu*kSideAPCBBoardsHigh/2,
5920 kSideAPCBBoardsLen/2);
5921
5922 TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideAPCBBoardsWide/2,
5923 kSideAPCBBoardsEpoxy*kSideAPCBBoardsHigh/2,
5924 kSideAPCBBoardsLen/2);
5925
5926 TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideAPCBBoardsWide/2,
5927 kSideAPCBBoardsPlast*kSideAPCBBoardsHigh/2,
5928 kSideAPCBBoardsLen/2);
5929
5930 TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideAPCBBoardsWide/2,
5931 kSideAPCBBoardsSteel*kSideAPCBBoardsHigh/2,
5932 kSideAPCBBoardsLen/2);
5933
5934 TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideAPCBBoardsWide/2,
5935 kSideAPCBBoardsPPS*kSideAPCBBoardsHigh/2,
5936 kSideAPCBBoardsLen/2);
5937
798b4e0c 5938
5939 // We have all shapes: now create the real volumes
0801d201 5940 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
57126ea1 5941 TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
5942 TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
0801d201 5943 TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$");
5944 TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$");
5945 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
57126ea1 5946 TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
5947 TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$");
0801d201 5948 TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
5949 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
5950 TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
57126ea1 5951 TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
5952 TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$");
0801d201 5953 TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$");
798b4e0c 5954
5955 TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSDDSideAForwTrayCover",
5956 forwardCover, medAl);
5957
5958 forwardTrayCover->SetVisibility(kTRUE);
5959 forwardTrayCover->SetLineColor(kMagenta+1); // Purple
5960 forwardTrayCover->SetLineWidth(1);
5961 forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
5962 forwardTrayCover->SetFillStyle(4000); // 0% transparent
5963
5964 TGeoVolume *externalTraySDD = new TGeoVolume("ITSsuppSDDSideAExternalTray",
5965 externalTray, medAl);
5966
5967 externalTraySDD->SetVisibility(kTRUE);
5968 externalTraySDD->SetLineColor(6); // Purple
5969 externalTraySDD->SetLineWidth(1);
5970 externalTraySDD->SetFillColor(externalTraySDD->GetLineColor());
5971 externalTraySDD->SetFillStyle(4000); // 0% transparent
5972
5973 TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSDDSideAExtTrayCover",
5974 externCover, medAntic);
5975
5976 externTrayCover->SetVisibility(kTRUE);
5977 externTrayCover->SetLineColor(kMagenta+1); // Purple
5978 externTrayCover->SetLineWidth(1);
5979 externTrayCover->SetFillColor(externTrayCover->GetLineColor());
5980 externTrayCover->SetFillStyle(4000); // 0% transparent
5981
21ea473f 5982 TGeoVolume *pomCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifPOM",
57126ea1 5983 coolManifPOM, medPOM);
5984
21ea473f 5985 pomCoolManif->SetVisibility(kTRUE);
5986 pomCoolManif->SetLineColor(kRed); // Red
5987 pomCoolManif->SetLineWidth(1);
5988 pomCoolManif->SetFillColor(pomCoolManif->GetLineColor());
5989 pomCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 5990
21ea473f 5991 TGeoVolume *steelCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifSteel",
57126ea1 5992 coolManifSteel, medSteel);
5993
21ea473f 5994 steelCoolManif->SetVisibility(kTRUE);
5995 steelCoolManif->SetLineColor(kBlue); // Blue
5996 steelCoolManif->SetLineWidth(1);
5997 steelCoolManif->SetFillColor(steelCoolManif->GetLineColor());
5998 steelCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 5999
21ea473f 6000 TGeoVolume *waterCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifWater",
57126ea1 6001 coolManifWater, medWater);
6002
21ea473f 6003 waterCoolManif->SetVisibility(kTRUE);
6004 waterCoolManif->SetLineColor(33); // Light Blue
6005 waterCoolManif->SetLineWidth(1);
6006 waterCoolManif->SetFillColor(waterCoolManif->GetLineColor());
6007 waterCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 6008
21ea473f 6009 TGeoVolume *alCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifAl",
57126ea1 6010 coolManifAl, medAl);
6011
21ea473f 6012 alCoolManif->SetVisibility(kTRUE);
6013 alCoolManif->SetLineColor(6); // Purple
6014 alCoolManif->SetLineWidth(1);
6015 alCoolManif->SetFillColor(alCoolManif->GetLineColor());
6016 alCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 6017
21ea473f 6018 TGeoVolume *purCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesPUR",
57126ea1 6019 coolTubesPUR, medPUR);
6020
21ea473f 6021 purCoolTubes->SetVisibility(kTRUE);
6022 purCoolTubes->SetLineColor(kRed); // Red
6023 purCoolTubes->SetLineWidth(1);
6024 purCoolTubes->SetFillColor(purCoolTubes->GetLineColor());
6025 purCoolTubes->SetFillStyle(4000); // 0% transparent
57126ea1 6026
21ea473f 6027 TGeoVolume *waterCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesWater",
57126ea1 6028 coolTubesWater, medWater);
6029
21ea473f 6030 waterCoolTubes->SetVisibility(kTRUE);
6031 waterCoolTubes->SetLineColor(33); // Light Blue
6032 waterCoolTubes->SetLineWidth(1);
6033 waterCoolTubes->SetFillColor(waterCoolTubes->GetLineColor());
6034 waterCoolTubes->SetFillStyle(4000); // 0% transparent
57126ea1 6035
21ea473f 6036 TGeoVolume *airCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesAir",
57126ea1 6037 coolTubesAir, medAir);
6038
21ea473f 6039 airCoolTubes->SetVisibility(kTRUE);
6040 airCoolTubes->SetLineColor(41);
6041 airCoolTubes->SetLineWidth(1);
6042 airCoolTubes->SetFillColor(airCoolTubes->GetLineColor());
6043 airCoolTubes->SetFillStyle(4000); // 0% transparent
57126ea1 6044
21ea473f 6045 TGeoVolume *pbtOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnPBT",
57126ea1 6046 optConnPBT, medPBT);
6047
21ea473f 6048 pbtOptConn->SetVisibility(kTRUE);
6049 pbtOptConn->SetLineColor(kRed); // Red
6050 pbtOptConn->SetLineWidth(1);
6051 pbtOptConn->SetFillColor(pbtOptConn->GetLineColor());
6052 pbtOptConn->SetFillStyle(4000); // 0% transparent
57126ea1 6053
21ea473f 6054 TGeoVolume *steelOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnSteel",
57126ea1 6055 optConnSteel, medSteel);
6056
21ea473f 6057 steelOptConn->SetVisibility(kTRUE);
6058 steelOptConn->SetLineColor(kBlue); // Blue
6059 steelOptConn->SetLineWidth(1);
6060 steelOptConn->SetFillColor(steelOptConn->GetLineColor());
6061 steelOptConn->SetFillStyle(4000); // 0% transparent
57126ea1 6062
21ea473f 6063 TGeoVolume *alOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnAl",
57126ea1 6064 optConnAl, medAl);
6065
21ea473f 6066 alOptConn->SetVisibility(kTRUE);
6067 alOptConn->SetLineColor(6); // Purple
6068 alOptConn->SetLineWidth(1);
6069 alOptConn->SetFillColor(alOptConn->GetLineColor());
6070 alOptConn->SetFillStyle(4000); // 0% transparent
57126ea1 6071
21ea473f 6072 TGeoVolume *optFibs = new TGeoVolume("ITSsuppSDDSideAOptFibs",
57126ea1 6073 opticalFibs, medOptFib);
6074
21ea473f 6075 optFibs->SetVisibility(kTRUE);
6076 optFibs->SetLineColor(kOrange+2); // Orange
6077 optFibs->SetLineWidth(1);
6078 optFibs->SetFillColor(optFibs->GetLineColor());
6079 optFibs->SetFillStyle(4000); // 0% transparent
57126ea1 6080
21ea473f 6081 TGeoVolume *cuInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsCu",
57126ea1 6082 inputCabsCu, medCu);
6083
21ea473f 6084 cuInputCabs->SetVisibility(kTRUE);
6085 cuInputCabs->SetLineColor(kBlack); // Black
6086 cuInputCabs->SetLineWidth(1);
6087 cuInputCabs->SetFillColor(cuInputCabs->GetLineColor());
6088 cuInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6089
21ea473f 6090 TGeoVolume *plastInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPlast",
57126ea1 6091 inputCabsPlast, medPUR);
6092
21ea473f 6093 plastInputCabs->SetVisibility(kTRUE);
6094 plastInputCabs->SetLineColor(kRed); // Red
6095 plastInputCabs->SetLineWidth(1);
6096 plastInputCabs->SetFillColor(plastInputCabs->GetLineColor());
6097 plastInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6098
21ea473f 6099 TGeoVolume *alInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsAl",
57126ea1 6100 inputCabsAl, medAl);
6101
21ea473f 6102 alInputCabs->SetVisibility(kTRUE);
6103 alInputCabs->SetLineColor(6); // Purple
6104 alInputCabs->SetLineWidth(1);
6105 alInputCabs->SetFillColor(alInputCabs->GetLineColor());
6106 alInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6107
21ea473f 6108 TGeoVolume *kaptonInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsKapton",
57126ea1 6109 inputCabsKapton, medKapton);
6110
21ea473f 6111 kaptonInputCabs->SetVisibility(kTRUE);
6112 kaptonInputCabs->SetLineColor(14); //
6113 kaptonInputCabs->SetLineWidth(1);
6114 kaptonInputCabs->SetFillColor(kaptonInputCabs->GetLineColor());
6115 kaptonInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6116
1c5895a3 6117 TGeoVolume *polyaxInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPOLYAX",
57126ea1 6118 inputCabsPOLYAX, medPOLYAX);
6119
1c5895a3 6120 polyaxInputCabs->SetVisibility(kTRUE);
6121 polyaxInputCabs->SetLineColor(34); //
6122 polyaxInputCabs->SetLineWidth(1);
6123 polyaxInputCabs->SetFillColor(polyaxInputCabs->GetLineColor());
6124 polyaxInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6125
21ea473f 6126 TGeoVolume *cuOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsCu",
57126ea1 6127 outputCabsCu, medCu);
6128
21ea473f 6129 cuOutputCabs->SetVisibility(kTRUE);
6130 cuOutputCabs->SetLineColor(kBlack); // Black
6131 cuOutputCabs->SetLineWidth(1);
6132 cuOutputCabs->SetFillColor(cuOutputCabs->GetLineColor());
6133 cuOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6134
21ea473f 6135 TGeoVolume *plastOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPlast",
57126ea1 6136 outputCabsPlast, medPUR);
6137
21ea473f 6138 plastOutputCabs->SetVisibility(kTRUE);
6139 plastOutputCabs->SetLineColor(kRed); // Red
6140 plastOutputCabs->SetLineWidth(1);
6141 plastOutputCabs->SetFillColor(plastOutputCabs->GetLineColor());
6142 plastOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6143
21ea473f 6144 TGeoVolume *alOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsAl",
57126ea1 6145 outputCabsAl, medAl);
6146
21ea473f 6147 alOutputCabs->SetVisibility(kTRUE);
6148 alOutputCabs->SetLineColor(6); // Purple
6149 alOutputCabs->SetLineWidth(1);
6150 alOutputCabs->SetFillColor(alOutputCabs->GetLineColor());
6151 alOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6152
21ea473f 6153 TGeoVolume *kaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsKapton",
57126ea1 6154 outputCabsKapton, medKapton);
6155
21ea473f 6156 kaptonOutputCabs->SetVisibility(kTRUE);
6157 kaptonOutputCabs->SetLineColor(14); //
6158 kaptonOutputCabs->SetLineWidth(1);
6159 kaptonOutputCabs->SetFillColor(kaptonOutputCabs->GetLineColor());
6160 kaptonOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6161
1c5895a3 6162 TGeoVolume *polyaxOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPOLYAX",
57126ea1 6163 outputCabsPOLYAX, medPOLYAX);
6164
1c5895a3 6165 polyaxOutputCabs->SetVisibility(kTRUE);
6166 polyaxOutputCabs->SetLineColor(34); //
6167 polyaxOutputCabs->SetLineWidth(1);
6168 polyaxOutputCabs->SetFillColor(polyaxOutputCabs->GetLineColor());
6169 polyaxOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6170
21ea473f 6171 TGeoVolume *cuPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsCu",
57126ea1 6172 pcbBoardsCu, medCu);
6173
21ea473f 6174 cuPCBBoards->SetVisibility(kTRUE);
6175 cuPCBBoards->SetLineColor(kBlack); // Black
6176 cuPCBBoards->SetLineWidth(1);
6177 cuPCBBoards->SetFillColor(cuPCBBoards->GetLineColor());
6178 cuPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6179
21ea473f 6180 TGeoVolume *epoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsEpoxy",
57126ea1 6181 pcbBoardsEpoxy, medEpoxy);
6182
21ea473f 6183 epoxyPCBBoards->SetVisibility(kTRUE);
6184 epoxyPCBBoards->SetLineColor(22); //
6185 epoxyPCBBoards->SetLineWidth(1);
6186 epoxyPCBBoards->SetFillColor(epoxyPCBBoards->GetLineColor());
6187 epoxyPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6188
21ea473f 6189 TGeoVolume *plastPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPlast",
57126ea1 6190 pcbBoardsPlast, medPUR);
6191
21ea473f 6192 plastPCBBoards->SetVisibility(kTRUE);
6193 plastPCBBoards->SetLineColor(kRed); // Red
6194 plastPCBBoards->SetLineWidth(1);
6195 plastPCBBoards->SetFillColor(plastPCBBoards->GetLineColor());
6196 plastPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6197
21ea473f 6198 TGeoVolume *steelPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsSteel",
57126ea1 6199 pcbBoardsSteel, medSteel);
6200
21ea473f 6201 steelPCBBoards->SetVisibility(kTRUE);
6202 steelPCBBoards->SetLineColor(kBlue); // Blue
6203 steelPCBBoards->SetLineWidth(1);
6204 steelPCBBoards->SetFillColor(steelPCBBoards->GetLineColor());
6205 steelPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6206
1c5895a3 6207 TGeoVolume *ppsPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPPS",
57126ea1 6208 pcbBoardsPPS, medPPS);
6209
1c5895a3 6210 ppsPCBBoards->SetVisibility(kTRUE);
6211 ppsPCBBoards->SetLineColor(kGreen); // Green
6212 ppsPCBBoards->SetLineWidth(1);
6213 ppsPCBBoards->SetFillColor(ppsPCBBoards->GetLineColor());
6214 ppsPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6215
798b4e0c 6216
6217 // Now build up the tray
57126ea1 6218 yloc = kForwardTrayTotalHeight - forwardCover->GetY(3);
6219 zloc = kForwardTrayUpperLength - kForwardCoverLength;
798b4e0c 6220 cableTrayA->AddNode(forwardTrayCover, 1,
6221 new TGeoTranslation( 0, yloc, zloc) );
6222
6223 Double_t totalhi = kExternTrayTotalHeight + kExternCoverThick
6224 - kExternCoverYTrans;
6225
57126ea1 6226 yloc = totalhi*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
6227 kExternTrayTotalHeight*CosD(kTrayAZRot);
798b4e0c 6228 zloc = kExternTrayZTrans + totalhi*SinD(kTrayAZRot);
6229 cableTrayA->AddNode(externalTraySDD, 1,
6230 new TGeoCombiTrans( 0, yloc, zloc,
6231 new TGeoRotation("", 0,-kTrayAZRot, 0) ) );
6232
57126ea1 6233 yloc = kExternCoverThick*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
6234 kExternCoverYTrans*CosD(kTrayAZRot)/2-0.01;
6235 zloc = kExternTrayZTrans + kExternCoverThick*SinD(kTrayAZRot);
798b4e0c 6236 cableTrayA->AddNode(externTrayCover,1,
6237 new TGeoCombiTrans( 0, yloc, zloc,
6238 new TGeoRotation("", 0,-kTrayAZRot, 0) ) );
6239
57126ea1 6240 yloc = kForwardTrayThick + coolManifPOM->GetDY();
6241 zloc = coolManifPOM->GetDZ();
21ea473f 6242 cableTrayA->AddNode(pomCoolManif, 1,
57126ea1 6243 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 6244
57126ea1 6245 yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
21ea473f 6246 cableTrayA->AddNode(steelCoolManif, 1,
57126ea1 6247 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 6248
57126ea1 6249 yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
21ea473f 6250 cableTrayA->AddNode(waterCoolManif, 1,
57126ea1 6251 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 6252
57126ea1 6253 yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
21ea473f 6254 cableTrayA->AddNode(alCoolManif, 1,
57126ea1 6255 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 6256
21ea473f 6257 cableTrayA->AddNode(purCoolTubes,1,
57126ea1 6258 new TGeoCombiTrans( 0, 0, 0,
6259 new TGeoRotation("",-90, 90, 90) ) );
21ea473f 6260 cableTrayA->AddNode(waterCoolTubes,1,
57126ea1 6261 new TGeoCombiTrans( 0, 0, 0,
6262 new TGeoRotation("",-90, 90, 90) ) );
21ea473f 6263 cableTrayA->AddNode(airCoolTubes,1,
57126ea1 6264 new TGeoCombiTrans( 0, 0, 0,
6265 new TGeoRotation("",-90, 90, 90) ) );
6266
6267 xloc = coolManifPOM->GetDX() + optConnPBT->GetDX();
6268 yloc = kForwardTrayThick + optConnPBT->GetDY();
6269 zloc = optConnPBT->GetDZ();
21ea473f 6270 cableTrayA->AddNode(pbtOptConn, 1,
57126ea1 6271 new TGeoTranslation( xloc, yloc, zloc) );
21ea473f 6272 cableTrayA->AddNode(pbtOptConn, 2,
57126ea1 6273 new TGeoTranslation(-xloc, yloc, zloc) );
6274
6275 yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
21ea473f 6276 cableTrayA->AddNode(steelOptConn, 1,
57126ea1 6277 new TGeoTranslation( xloc, yloc, zloc) );
21ea473f 6278 cableTrayA->AddNode(steelOptConn, 2,
57126ea1 6279 new TGeoTranslation(-xloc, yloc, zloc) );
6280
6281 yloc += optConnSteel->GetDY() + optConnAl->GetDY();
21ea473f 6282 cableTrayA->AddNode(alOptConn, 1,
57126ea1 6283 new TGeoTranslation( xloc, yloc, zloc) );
21ea473f 6284 cableTrayA->AddNode(alOptConn, 2,
57126ea1 6285 new TGeoTranslation(-xloc, yloc, zloc) );
6286
6287
6288 xloc = kSideACoolTubesWide/2 + kSideAOptFibsWide/2;
21ea473f 6289 cableTrayA->AddNode(optFibs,1,
57126ea1 6290 new TGeoCombiTrans( xloc, 0, 0,
6291 new TGeoRotation("",-90, 90, 90) ) );
21ea473f 6292 cableTrayA->AddNode(optFibs,2,
57126ea1 6293 new TGeoCombiTrans(-xloc, 0, 0,
6294 new TGeoRotation("",-90, 90, 90) ) );
6295
6296 yloc = kForwardTrayTotalHeight - forwardCover->GetY(3) -
6297 kSideAInputCablesYTrans - inputCabsPOLYAX->GetDY();
6298 zloc = inputCabsPOLYAX->GetDZ();
1c5895a3 6299 cableTrayA->AddNode(polyaxInputCabs, 1,
57126ea1 6300 new TGeoTranslation( 0, yloc, zloc) );
6301
6302 yloc -= (inputCabsPOLYAX->GetDY() + inputCabsKapton->GetDY());
21ea473f 6303 cableTrayA->AddNode(kaptonInputCabs, 1,
57126ea1 6304 new TGeoTranslation( 0, yloc, zloc) );
6305
6306 yloc -= (inputCabsKapton->GetDY() + inputCabsAl->GetDY());
21ea473f 6307 cableTrayA->AddNode(alInputCabs, 1,
57126ea1 6308 new TGeoTranslation( 0, yloc, zloc) );
6309
6310 yloc -= (inputCabsAl->GetDY() + inputCabsPlast->GetDY());
21ea473f 6311 cableTrayA->AddNode(plastInputCabs, 1,
57126ea1 6312 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 6313
57126ea1 6314 yloc -= (inputCabsPlast->GetDY() + inputCabsCu->GetDY());
21ea473f 6315 cableTrayA->AddNode(cuInputCabs, 1,
57126ea1 6316 new TGeoTranslation( 0, yloc, zloc) );
6317
6318 yloc -= (inputCabsCu->GetDY()+pcbBoardsPPS->GetDY()+kSideAPCBBoardsYTrans);
6319 zloc += pcbBoardsPPS->GetDZ();
1c5895a3 6320 cableTrayA->AddNode(ppsPCBBoards, 1,
57126ea1 6321 new TGeoTranslation( 0, yloc, zloc) );
6322
6323 yloc -= (pcbBoardsPPS->GetDY()+pcbBoardsSteel->GetDY());
21ea473f 6324 cableTrayA->AddNode(steelPCBBoards, 1,
57126ea1 6325 new TGeoTranslation( 0, yloc, zloc) );
6326
6327 yloc -= (pcbBoardsSteel->GetDY()+pcbBoardsPlast->GetDY());
21ea473f 6328 cableTrayA->AddNode(plastPCBBoards, 1,
57126ea1 6329 new TGeoTranslation( 0, yloc, zloc) );
6330
6331 yloc -= (pcbBoardsPlast->GetDY()+pcbBoardsEpoxy->GetDY());
21ea473f 6332 cableTrayA->AddNode(epoxyPCBBoards, 1,
57126ea1 6333 new TGeoTranslation( 0, yloc, zloc) );
6334
6335 yloc -= (pcbBoardsEpoxy->GetDY()+pcbBoardsCu->GetDY());
21ea473f 6336 cableTrayA->AddNode(cuPCBBoards, 1,
57126ea1 6337 new TGeoTranslation( 0, yloc, zloc) );
6338
21ea473f 6339 cableTrayA->AddNode(cuOutputCabs,1,
57126ea1 6340 new TGeoCombiTrans( 0, 0, 0,
6341 new TGeoRotation("",-90, 90, 90) ) );
21ea473f 6342 cableTrayA->AddNode(plastOutputCabs,1,
57126ea1 6343 new TGeoCombiTrans( 0, 0, 0,
6344 new TGeoRotation("",-90, 90, 90) ) );
21ea473f 6345 cableTrayA->AddNode(alOutputCabs,1,
57126ea1 6346 new TGeoCombiTrans( 0, 0, 0,
6347 new TGeoRotation("",-90, 90, 90) ) );
21ea473f 6348 cableTrayA->AddNode(kaptonOutputCabs,1,
57126ea1 6349 new TGeoCombiTrans( 0, 0, 0,
6350 new TGeoRotation("",-90, 90, 90) ) );
1c5895a3 6351 cableTrayA->AddNode(polyaxOutputCabs,1,
57126ea1 6352 new TGeoCombiTrans( 0, 0, 0,
6353 new TGeoRotation("",-90, 90, 90) ) );
6354
6355
6356 // Finally put everything in the mother volume
798b4e0c 6357 Double_t rforw = kTrayARTrans + kExternTrayTotalHeight +
6358 kExternCoverSideThick -
6359 kForwardTrayTailHeight;
6360
6361 alpharot = -kTrayAFirstRotAng;
6362 xloc = rforw*SinD(alpharot);
6363 yloc = rforw*CosD(alpharot);
6364 zloc = kTrayAZTrans + kTrayAZToSupportRing - kForwardTrayUpperLength;
6365
57126ea1 6366 moth->AddNode(cableTrayA,1,
798b4e0c 6367 new TGeoCombiTrans( xloc, yloc, zloc,
6368 new TGeoRotation("",-alpharot,0,0) ) );
6369
6370 alpharot += 180;
6371 xloc = rforw*SinD(alpharot);
6372 yloc = rforw*CosD(alpharot);
57126ea1 6373 moth->AddNode(cableTrayA,2,
798b4e0c 6374 new TGeoCombiTrans( xloc, yloc, zloc,
6375 new TGeoRotation("",-alpharot,0,0) ) );
6376
6377 alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng;
6378 xloc = rforw*SinD(alpharot);
6379 yloc = rforw*CosD(alpharot);
57126ea1 6380 moth->AddNode(cableTrayA,3,
798b4e0c 6381 new TGeoCombiTrans( xloc, yloc, zloc,
6382 new TGeoRotation("",-alpharot,0,0) ) );
6383
6384 alpharot += 180;
6385 xloc = rforw*SinD(alpharot);
6386 yloc = rforw*CosD(alpharot);
57126ea1 6387 moth->AddNode(cableTrayA,4,
798b4e0c 6388 new TGeoCombiTrans( xloc, yloc, zloc,
6389 new TGeoRotation("",-alpharot,0,0) ) );
6390
6391
6392 return;
6393}
6394
aa177c73 6395//______________________________________________________________________
6396void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth,
43aefea7 6397 const TGeoManager *mgr){
aa177c73 6398//
6399// Creates the SDD cable trays which are outside the ITS support cones
6400// but still inside the TPC on Side C
6401// (part of this code is taken or anyway inspired to ServicesCableSupport
6402// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
6403//
6404// Input:
6405// moth : the TGeoVolume owing the volume structure
6406// mgr : the GeoManager (default gGeoManager)
6407// Output:
6408//
6409// Created: ??? Bjorn S. Nilsen
6410// Updated: 17 Apr 2010 Mario Sitta
6411//
6412// Technical data are taken from AutoCAD drawings and other (oral)
6413// information given by F.Tosello
6414//
6415
57126ea1 6416 // Dimensions and positions of the C-Side Cable Tray
6417 // (Change accordingly to CreateSDDSSDTraysSideC !)
aa177c73 6418 const Int_t kNumTraySideC = 4;
6419
57126ea1 6420 const Double_t kSideCHalfThick = 0.100 *fgkcm;
6421 const Double_t kSideCLength1 = 172.800 *fgkcm;
6422 const Double_t kSideCLength2 = 189.300 *fgkcm;
6423 const Double_t kBarCoolRmax = 0.4 *fgkcm;
6424 const Double_t kXShiftBarCool = 13.00 *fgkcm;
6425
aa177c73 6426 const Double_t kSideCFoldAngle = 5.00 *fgkDegree;
6427
57126ea1 6428 // Dimensions and positions of the Cable Tray elements
6429 const Double_t kSideCCoolManifHalfX = 4.25 *fgkcm;
6430 const Double_t kSideCCoolManifHalfY = 4.03 *fgkcm;
6431 const Double_t kSideCCoolManifHalfZ = 2.17 *fgkcm;
6432 const Double_t kSideCCoolManifPOMFrac = 0.0051;
6433 const Double_t kSideCCoolManifSteelFrac= 0.8502;
6434 const Double_t kSideCCoolManifWaterFrac= 0.0868;
6435 const Double_t kSideCCoolManifAlFrac = 0.0579;
6436
6437 const Double_t kSideCCoolTubesHigh = 1.88 *fgkcm;
6438 const Double_t kSideCCoolTubesTrans = 0.85 *fgkcm;
6439 const Double_t kSideCCoolTubesPURFrac = 0.5884;
6440 const Double_t kSideCCoolTubesWaterFrac= 0.4114;
6441 const Double_t kSideCCoolTubesAirFrac = 0.0002;
6442
6443 const Double_t kSideCOptConnHalfX = 0.90 *fgkcm;
6444 const Double_t kSideCOptConnHalfZ = 1.37 *fgkcm;
6445 const Double_t kSideCOptConnPBTFrac = 0.6798;
6446 const Double_t kSideCOptConnSteelFrac = 0.2421;
6447 const Double_t kSideCOptConnAlFrac = 0.0781;
6448
6449 const Double_t kSideCOptFibsWide = 0.71 *fgkcm;
6450 const Double_t kSideCOptFibsHigh = 3.20 *fgkcm;
6451 const Double_t kSideCOptFibsTrans = 0.20 *fgkcm;
6452
6453 const Double_t kSideCInputCablesLen = 31.45 *fgkcm;
6454 const Double_t kSideCInputCablesWide = 12.50 *fgkcm;
6455 const Double_t kSideCInputCablesHigh = 0.95 *fgkcm;
6456 const Double_t kSideCInputCablesTrans = 1.15 *fgkcm;
6457 const Double_t kSideCInputCablesCu = 0.7405;
6458 const Double_t kSideCInputCablesPlast = 0.1268;
6459 const Double_t kSideCInputCablesAl = 0.0057;
6460 const Double_t kSideCInputCablesKapton = 0.0172;
6461 const Double_t kSideCInputCablesPOLYAX = 0.1098;
6462
6463 const Double_t kSideCOutputCablesX0 = 27.40 *fgkcm;
5d9d4033 6464 const Double_t kSideCOutputCablesWide = 8.50 *fgkcm;
57126ea1 6465 const Double_t kSideCOutputCablesHigh = 1.18 *fgkcm;
6466 const Double_t kSideCOutputCablesCu = 0.6775;
6467 const Double_t kSideCOutputCablesPlast = 0.1613;
6468 const Double_t kSideCOutputCablesAl = 0.0078;
6469 const Double_t kSideCOutputCablesKapton= 0.0234;
6470 const Double_t kSideCOutputCablesPOLYAX= 0.1300;
6471
6472 const Double_t kSideCPCBBoardsHalfX = 6.30 *fgkcm;
6473 const Double_t kSideCPCBBoardsHalfY = 2.00 *fgkcm;
6474 const Double_t kSideCPCBBoardsHalfZ = 21.93 *fgkcm;
6475 const Double_t kSideCPCBBoardsCu = 0.3864;
6476 const Double_t kSideCPCBBoardsEpoxy = 0.1491;
6477 const Double_t kSideCPCBBoardsPlast = 0.0579;
6478 const Double_t kSideCPCBBoardsSteel = 0.1517;
6479 const Double_t kSideCPCBBoardsPPS = 0.2549;
6480
aa177c73 6481 // Overall position and rotation of the C-Side Cable Trays
6482 const Double_t kTraySideCRPos = 45.30 *fgkcm;
6483 const Double_t kTraySideCZPos = -102.40 *fgkcm;
6484 const Double_t kTraySideCAlphaRot[kNumTraySideC] = { -23.0, 59.0,
6485 /* from SSD tray position */ 180.-23.0, 180.+59.0};
6486
6487
6488 // Local variables
57126ea1 6489 Double_t xprof[6], yprof[6];
6490 Double_t height, xloc, yloc, zloc, alpharot, alphafold;
aa177c73 6491
6492
6493 // The assembly holding the metallic structure
57126ea1 6494 TGeoVolumeAssembly *trayStructure = CreateSDDSSDTraysSideC("ITSsupportSDDTrayC");
6495
6496 // Now the volumes inside it
6497 // The cooling manifold: four boxes
6498 // (X and Z are inverted on tray reference system)
6499 TGeoBBox *coolManifPOM = new TGeoBBox(kSideCCoolManifHalfZ,
6500 kSideCCoolManifPOMFrac*kSideCCoolManifHalfY,
6501 kSideCCoolManifHalfX);
6502
6503 TGeoBBox *coolManifSteel = new TGeoBBox(kSideCCoolManifHalfZ,
6504 kSideCCoolManifSteelFrac*kSideCCoolManifHalfY,
6505 kSideCCoolManifHalfX);
6506
6507 TGeoBBox *coolManifWater = new TGeoBBox(kSideCCoolManifHalfZ,
6508 kSideCCoolManifWaterFrac*kSideCCoolManifHalfY,
6509 kSideCCoolManifHalfX);
6510
6511 TGeoBBox *coolManifAl = new TGeoBBox(kSideCCoolManifHalfZ,
6512 kSideCCoolManifAlFrac*kSideCCoolManifHalfY,
6513 kSideCCoolManifHalfX);
6514
6515 // The cooling tubes: three Xtru's
6516 alpharot = kSideCFoldAngle*TMath::DegToRad();
6517
6518 TGeoXtru *coolTubesPUR = new TGeoXtru(2);
6519
6520 height = kSideCCoolTubesHigh*kSideCCoolTubesPURFrac;
6521
6522 xprof[0] = 2*kSideCCoolManifHalfZ;
6523 yprof[0] = 2*kSideCHalfThick + kSideCCoolTubesTrans;
6524 xprof[1] = kSideCLength1;
6525 yprof[1] = yprof[0];
6526 xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
6527 yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
6528 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6529 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6530 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6531 height, xprof[4], yprof[4]);
6532 xprof[5] = xprof[0];
6533 yprof[5] = yprof[0] + height;
6534
6535 coolTubesPUR->DefinePolygon(6, xprof, yprof);
6536 coolTubesPUR->DefineSection(0,-kSideCCoolManifHalfX);
6537 coolTubesPUR->DefineSection(1, kSideCCoolManifHalfX);
6538
6539 TGeoXtru *coolTubesWater = new TGeoXtru(2);
6540
6541 height = kSideCCoolTubesHigh*kSideCCoolTubesWaterFrac;
6542
6543 xprof[0] = coolTubesPUR->GetX(5);
6544 yprof[0] = coolTubesPUR->GetY(5);
6545 xprof[1] = coolTubesPUR->GetX(4);
6546 yprof[1] = coolTubesPUR->GetY(4);
6547 xprof[2] = coolTubesPUR->GetX(3);
6548 yprof[2] = coolTubesPUR->GetY(3);
6549 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6550 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6551 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6552 height, xprof[4], yprof[4]);
6553 xprof[5] = xprof[0];
6554 yprof[5] = yprof[0] + height;
6555
6556 coolTubesWater->DefinePolygon(6, xprof, yprof);
6557 coolTubesWater->DefineSection(0,-kSideCCoolManifHalfX);
6558 coolTubesWater->DefineSection(1, kSideCCoolManifHalfX);
6559
6560 TGeoXtru *coolTubesAir = new TGeoXtru(2);
6561
6562 height = kSideCCoolTubesHigh*kSideCCoolTubesAirFrac;
6563
6564 xprof[0] = coolTubesWater->GetX(5);
6565 yprof[0] = coolTubesWater->GetY(5);
6566 xprof[1] = coolTubesWater->GetX(4);
6567 yprof[1] = coolTubesWater->GetY(4);
6568 xprof[2] = coolTubesWater->GetX(3);
6569 yprof[2] = coolTubesWater->GetY(3);
6570 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6571 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6572 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6573 height, xprof[4], yprof[4]);
6574 xprof[5] = xprof[0];
6575 yprof[5] = yprof[0] + height;
6576
6577 coolTubesAir->DefinePolygon(6, xprof, yprof);
6578 coolTubesAir->DefineSection(0,-kSideCCoolManifHalfX);
6579 coolTubesAir->DefineSection(1, kSideCCoolManifHalfX);
6580
6581 // The optical fiber connectors: three boxes
6582 // (X and Z are inverted on tray reference system)
6583 TGeoBBox *optConnPBT = new TGeoBBox(kSideCOptConnHalfZ,
6584 kSideCOptConnPBTFrac*kSideCCoolManifHalfY,
6585 kSideCOptConnHalfX);
6586
6587 TGeoBBox *optConnSteel = new TGeoBBox(kSideCOptConnHalfZ,
6588 kSideCOptConnSteelFrac*kSideCCoolManifHalfY,
6589 kSideCOptConnHalfX);
6590
6591 TGeoBBox *optConnAl = new TGeoBBox(kSideCOptConnHalfZ,
6592 kSideCOptConnAlFrac*kSideCCoolManifHalfY,
6593 kSideCOptConnHalfX);
6594
6595 // The optical fibers: a Xtru
6596 TGeoXtru *opticalFibs = new TGeoXtru(2);
6597
6598 xprof[0] = 2*kSideCOptConnHalfZ;
6599 yprof[0] = 2*kSideCHalfThick + kSideCOptFibsTrans;
6600 xprof[1] = kSideCLength1;
6601 yprof[1] = yprof[0];
6602 xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
6603 yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
6604 xprof[3] = xprof[2] - kSideCOptFibsHigh*TMath::Sin(alpharot);
6605 yprof[3] = yprof[2] + kSideCOptFibsHigh*TMath::Cos(alpharot);
6606 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6607 kSideCOptFibsHigh, xprof[4], yprof[4]);
6608 xprof[5] = xprof[0];
6609 yprof[5] = yprof[0] + kSideCOptFibsHigh;
6610
6611 opticalFibs->DefinePolygon(6, xprof, yprof);
6612 opticalFibs->DefineSection(0,-kSideCOptFibsWide/2);
6613 opticalFibs->DefineSection(1, kSideCOptFibsWide/2);
6614
6615 // The input cables: five boxes
6616 // (X and Z are inverted on tray reference system)
6617 TGeoBBox *inputCabsCu = new TGeoBBox(kSideCInputCablesLen/2,
6618 kSideCInputCablesCu*kSideCInputCablesHigh/2,
6619 kSideCInputCablesWide/2);
6620
6621 TGeoBBox *inputCabsPlast = new TGeoBBox(kSideCInputCablesLen/2,
6622 kSideCInputCablesPlast*kSideCInputCablesHigh/2,
6623 kSideCInputCablesWide/2);
6624
6625 TGeoBBox *inputCabsAl = new TGeoBBox(kSideCInputCablesLen/2,
6626 kSideCInputCablesAl*kSideCInputCablesHigh/2,
6627 kSideCInputCablesWide/2);
6628
6629 TGeoBBox *inputCabsKapton = new TGeoBBox(kSideCInputCablesLen/2,
6630 kSideCInputCablesKapton*kSideCInputCablesHigh/2,
6631 kSideCInputCablesWide/2);
6632
6633 TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideCInputCablesLen/2,
6634 kSideCInputCablesPOLYAX*kSideCInputCablesHigh/2,
6635 kSideCInputCablesWide/2);
6636
6637 // The output cables: five Xtru
6638 TGeoXtru *outputCabsCu = new TGeoXtru(2);
6639
6640 height = kSideCOutputCablesCu*kSideCOutputCablesHigh;
6641
6642 xprof[0] = coolTubesAir->GetX(5) + kSideCOutputCablesX0;
6643 yprof[0] = coolTubesAir->GetY(5);
6644 xprof[1] = coolTubesAir->GetX(4);
6645 yprof[1] = coolTubesAir->GetY(4);
6646 xprof[2] = coolTubesAir->GetX(3);
6647 yprof[2] = coolTubesAir->GetY(3);
6648 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6649 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6650 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6651 height, xprof[4], yprof[4]);
6652 xprof[5] = xprof[0];
6653 yprof[5] = yprof[0] + height;
6654
6655 outputCabsCu->DefinePolygon(6, xprof, yprof);
6656 outputCabsCu->DefineSection(0,-kSideCOutputCablesWide/2);
6657 outputCabsCu->DefineSection(1, kSideCOutputCablesWide/2);
6658
6659 TGeoXtru *outputCabsPlast = new TGeoXtru(2);
6660
6661 height = kSideCOutputCablesPlast*kSideCOutputCablesHigh;
6662
6663 xprof[0] = outputCabsCu->GetX(5);
6664 yprof[0] = outputCabsCu->GetY(5);
6665 xprof[1] = outputCabsCu->GetX(4);
6666 yprof[1] = outputCabsCu->GetY(4);
6667 xprof[2] = outputCabsCu->GetX(3);
6668 yprof[2] = outputCabsCu->GetY(3);
6669 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6670 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6671 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6672 height, xprof[4], yprof[4]);
6673 xprof[5] = xprof[0];
6674 yprof[5] = yprof[0] + height;
6675
6676 outputCabsPlast->DefinePolygon(6, xprof, yprof);
6677 outputCabsPlast->DefineSection(0,-kSideCOutputCablesWide/2);
6678 outputCabsPlast->DefineSection(1, kSideCOutputCablesWide/2);
6679
6680 TGeoXtru *outputCabsAl = new TGeoXtru(2);
6681
6682 height = kSideCOutputCablesAl*kSideCOutputCablesHigh;
6683
6684 xprof[0] = outputCabsPlast->GetX(5);
6685 yprof[0] = outputCabsPlast->GetY(5);
6686 xprof[1] = outputCabsPlast->GetX(4);
6687 yprof[1] = outputCabsPlast->GetY(4);
6688 xprof[2] = outputCabsPlast->GetX(3);
6689 yprof[2] = outputCabsPlast->GetY(3);
6690 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6691 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6692 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6693 height, xprof[4], yprof[4]);
6694 xprof[5] = xprof[0];
6695 yprof[5] = yprof[0] + height;
6696
6697 outputCabsAl->DefinePolygon(6, xprof, yprof);
6698 outputCabsAl->DefineSection(0,-kSideCOutputCablesWide/2);
6699 outputCabsAl->DefineSection(1, kSideCOutputCablesWide/2);
6700
6701 TGeoXtru *outputCabsKapton = new TGeoXtru(2);
6702
6703 height = kSideCOutputCablesKapton*kSideCOutputCablesHigh;
6704
6705 xprof[0] = outputCabsAl->GetX(5);
6706 yprof[0] = outputCabsAl->GetY(5);
6707 xprof[1] = outputCabsAl->GetX(4);
6708 yprof[1] = outputCabsAl->GetY(4);
6709 xprof[2] = outputCabsAl->GetX(3);
6710 yprof[2] = outputCabsAl->GetY(3);
6711 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6712 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6713 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6714 height, xprof[4], yprof[4]);
6715 xprof[5] = xprof[0];
6716 yprof[5] = yprof[0] + height;
6717
6718 outputCabsKapton->DefinePolygon(6, xprof, yprof);
6719 outputCabsKapton->DefineSection(0,-kSideCOutputCablesWide/2);
6720 outputCabsKapton->DefineSection(1, kSideCOutputCablesWide/2);
6721
6722 TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
6723
6724 height = kSideCOutputCablesPOLYAX*kSideCOutputCablesHigh;
6725
6726 xprof[0] = outputCabsKapton->GetX(5);
6727 yprof[0] = outputCabsKapton->GetY(5);
6728 xprof[1] = outputCabsKapton->GetX(4);
6729 yprof[1] = outputCabsKapton->GetY(4);
6730 xprof[2] = outputCabsKapton->GetX(3);
6731 yprof[2] = outputCabsKapton->GetY(3);
6732 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6733 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6734 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6735 height, xprof[4], yprof[4]);
6736 xprof[5] = xprof[0];
6737 yprof[5] = yprof[0] + height;
6738
6739 outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
6740 outputCabsPOLYAX->DefineSection(0,-kSideCOutputCablesWide/2);
6741 outputCabsPOLYAX->DefineSection(1, kSideCOutputCablesWide/2);
6742
6743 // The PCB boards: five boxes
6744 // (X and Z are inverted on tray reference system)
6745 TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideCPCBBoardsHalfZ,
6746 kSideCPCBBoardsCu*kSideCPCBBoardsHalfY,
6747 kSideCPCBBoardsHalfX);
6748
6749 TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideCPCBBoardsHalfZ,
6750 kSideCPCBBoardsEpoxy*kSideCPCBBoardsHalfY,
6751 kSideCPCBBoardsHalfX);
6752
6753 TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideCPCBBoardsHalfZ,
6754 kSideCPCBBoardsPlast*kSideCPCBBoardsHalfY,
6755 kSideCPCBBoardsHalfX);
6756
6757 TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideCPCBBoardsHalfZ,
6758 kSideCPCBBoardsSteel*kSideCPCBBoardsHalfY,
6759 kSideCPCBBoardsHalfX);
6760
6761 TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideCPCBBoardsHalfZ,
6762 kSideCPCBBoardsPPS*kSideCPCBBoardsHalfY,
6763 kSideCPCBBoardsHalfX);
aa177c73 6764
6765
6766 // We have all shapes: now create the real volumes
57126ea1 6767 TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
0801d201 6768 TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$");
6769 TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$");
6770 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
6771 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
6772 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
57126ea1 6773 TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
0801d201 6774 TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
57126ea1 6775 TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
6776 TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$");
0801d201 6777 TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
57126ea1 6778 TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$");
0801d201 6779 TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$");
57126ea1 6780
21ea473f 6781 TGeoVolume *pomCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifPOM",
57126ea1 6782 coolManifPOM, medPOM);
6783
21ea473f 6784 pomCoolManif->SetVisibility(kTRUE);
6785 pomCoolManif->SetLineColor(kRed); // Red
6786 pomCoolManif->SetLineWidth(1);
6787 pomCoolManif->SetFillColor(pomCoolManif->GetLineColor());
6788 pomCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 6789
21ea473f 6790 TGeoVolume *steelCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifSteel",
57126ea1 6791 coolManifSteel, medSteel);
6792
21ea473f 6793 steelCoolManif->SetVisibility(kTRUE);
6794 steelCoolManif->SetLineColor(kBlue); // Blue
6795 steelCoolManif->SetLineWidth(1);
6796 steelCoolManif->SetFillColor(steelCoolManif->GetLineColor());
6797 steelCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 6798
21ea473f 6799 TGeoVolume *waterCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifWater",
57126ea1 6800 coolManifWater, medWater);
6801
21ea473f 6802 waterCoolManif->SetVisibility(kTRUE);
6803 waterCoolManif->SetLineColor(33); // Light Blue
6804 waterCoolManif->SetLineWidth(1);
6805 waterCoolManif->SetFillColor(waterCoolManif->GetLineColor());
6806 waterCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 6807
21ea473f 6808 TGeoVolume *alCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifAl",
57126ea1 6809 coolManifAl, medAl);
6810
21ea473f 6811 alCoolManif->SetVisibility(kTRUE);
6812 alCoolManif->SetLineColor(6); // Purple
6813 alCoolManif->SetLineWidth(1);
6814 alCoolManif->SetFillColor(alCoolManif->GetLineColor());
6815 alCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 6816
21ea473f 6817 TGeoVolume *purCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesPUR",
57126ea1 6818 coolTubesPUR, medPUR);
6819
21ea473f 6820 purCoolTubes->SetVisibility(kTRUE);
6821 purCoolTubes->SetLineColor(kRed); // Red
6822 purCoolTubes->SetLineWidth(1);
6823 purCoolTubes->SetFillColor(purCoolTubes->GetLineColor());
6824 purCoolTubes->SetFillStyle(4000); // 0% transparent
57126ea1 6825
21ea473f 6826 TGeoVolume *waterCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesWater",
57126ea1 6827 coolTubesWater, medWater);
6828
21ea473f 6829 waterCoolTubes->SetVisibility(kTRUE);
6830 waterCoolTubes->SetLineColor(33); // Light Blue
6831 waterCoolTubes->SetLineWidth(1);
6832 waterCoolTubes->SetFillColor(waterCoolTubes->GetLineColor());
6833 waterCoolTubes->SetFillStyle(4000); // 0% transparent
57126ea1 6834
21ea473f 6835 TGeoVolume *airCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesAir",
57126ea1 6836 coolTubesAir, medAir);
6837
21ea473f 6838 airCoolTubes->SetVisibility(kTRUE);
6839 airCoolTubes->SetLineColor(41);
6840 airCoolTubes->SetLineWidth(1);
6841 airCoolTubes->SetFillColor(airCoolTubes->GetLineColor());
6842 airCoolTubes->SetFillStyle(4000); // 0% transparent
57126ea1 6843
21ea473f 6844 TGeoVolume *pbtOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnPBT",
57126ea1 6845 optConnPBT, medPBT);
6846
21ea473f 6847 pbtOptConn->SetVisibility(kTRUE);
6848 pbtOptConn->SetLineColor(kRed); // Red
6849 pbtOptConn->SetLineWidth(1);
6850 pbtOptConn->SetFillColor(pbtOptConn->GetLineColor());
6851 pbtOptConn->SetFillStyle(4000); // 0% transparent
57126ea1 6852
21ea473f 6853 TGeoVolume *steelOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnSteel",
57126ea1 6854 optConnSteel, medSteel);
6855
21ea473f 6856 steelOptConn->SetVisibility(kTRUE);
6857 steelOptConn->SetLineColor(kBlue); // Blue
6858 steelOptConn->SetLineWidth(1);
6859 steelOptConn->SetFillColor(steelOptConn->GetLineColor());
6860 steelOptConn->SetFillStyle(4000); // 0% transparent
57126ea1 6861
21ea473f 6862 TGeoVolume *alOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnAl",
57126ea1 6863 optConnAl, medAl);
6864
21ea473f 6865 alOptConn->SetVisibility(kTRUE);
6866 alOptConn->SetLineColor(6); // Purple
6867 alOptConn->SetLineWidth(1);
6868 alOptConn->SetFillColor(alOptConn->GetLineColor());
6869 alOptConn->SetFillStyle(4000); // 0% transparent
57126ea1 6870
21ea473f 6871 TGeoVolume *optFibs = new TGeoVolume("ITSsuppSDDSideCOptFibs",
57126ea1 6872 opticalFibs, medOptFib);
6873
21ea473f 6874 optFibs->SetVisibility(kTRUE);
6875 optFibs->SetLineColor(kOrange+2); // Orange
6876 optFibs->SetLineWidth(1);
6877 optFibs->SetFillColor(optFibs->GetLineColor());
6878 optFibs->SetFillStyle(4000); // 0% transparent
57126ea1 6879
21ea473f 6880 TGeoVolume *cuInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsCu",
57126ea1 6881 inputCabsCu, medCu);
6882
21ea473f 6883 cuInputCabs->SetVisibility(kTRUE);
6884 cuInputCabs->SetLineColor(kBlack); // Black
6885 cuInputCabs->SetLineWidth(1);
6886 cuInputCabs->SetFillColor(cuInputCabs->GetLineColor());
6887 cuInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6888
21ea473f 6889 TGeoVolume *plastInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPlast",
57126ea1 6890 inputCabsPlast, medPUR);
6891
21ea473f 6892 plastInputCabs->SetVisibility(kTRUE);
6893 plastInputCabs->SetLineColor(kRed); // Red
6894 plastInputCabs->SetLineWidth(1);
6895 plastInputCabs->SetFillColor(plastInputCabs->GetLineColor());
6896 plastInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6897
21ea473f 6898 TGeoVolume *alInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsAl",
57126ea1 6899 inputCabsAl, medAl);
6900
21ea473f 6901 alInputCabs->SetVisibility(kTRUE);
6902 alInputCabs->SetLineColor(6); // Purple
6903 alInputCabs->SetLineWidth(1);
6904 alInputCabs->SetFillColor(alInputCabs->GetLineColor());
6905 alInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6906
21ea473f 6907 TGeoVolume *kaptonInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsKapton",
57126ea1 6908 inputCabsKapton, medKapton);
6909
21ea473f 6910 kaptonInputCabs->SetVisibility(kTRUE);
6911 kaptonInputCabs->SetLineColor(14); //
6912 kaptonInputCabs->SetLineWidth(1);
6913 kaptonInputCabs->SetFillColor(kaptonInputCabs->GetLineColor());
6914 kaptonInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6915
1c5895a3 6916 TGeoVolume *polyaxInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPOLYAX",
57126ea1 6917 inputCabsPOLYAX, medPOLYAX);
6918
1c5895a3 6919 polyaxInputCabs->SetVisibility(kTRUE);
6920 polyaxInputCabs->SetLineColor(34); //
6921 polyaxInputCabs->SetLineWidth(1);
6922 polyaxInputCabs->SetFillColor(polyaxInputCabs->GetLineColor());
6923 polyaxInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6924
21ea473f 6925 TGeoVolume *cuOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsCu",
57126ea1 6926 outputCabsCu, medCu);
6927
21ea473f 6928 cuOutputCabs->SetVisibility(kTRUE);
6929 cuOutputCabs->SetLineColor(kBlack); // Black
6930 cuOutputCabs->SetLineWidth(1);
6931 cuOutputCabs->SetFillColor(cuOutputCabs->GetLineColor());
6932 cuOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6933
21ea473f 6934 TGeoVolume *plastOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPlast",
57126ea1 6935 outputCabsPlast, medPUR);
6936
21ea473f 6937 plastOutputCabs->SetVisibility(kTRUE);
6938 plastOutputCabs->SetLineColor(kRed); // Red
6939 plastOutputCabs->SetLineWidth(1);
6940 plastOutputCabs->SetFillColor(plastOutputCabs->GetLineColor());
6941 plastOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6942
21ea473f 6943 TGeoVolume *alOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsAl",
57126ea1 6944 outputCabsAl, medAl);
6945
21ea473f 6946 alOutputCabs->SetVisibility(kTRUE);
6947 alOutputCabs->SetLineColor(6); // Purple
6948 alOutputCabs->SetLineWidth(1);
6949 alOutputCabs->SetFillColor(alOutputCabs->GetLineColor());
6950 alOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6951
21ea473f 6952 TGeoVolume *kaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsKapton",
57126ea1 6953 outputCabsKapton, medKapton);
6954
21ea473f 6955 kaptonOutputCabs->SetVisibility(kTRUE);
6956 kaptonOutputCabs->SetLineColor(14); //
6957 kaptonOutputCabs->SetLineWidth(1);
6958 kaptonOutputCabs->SetFillColor(kaptonOutputCabs->GetLineColor());
6959 kaptonOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6960
1c5895a3 6961 TGeoVolume *polyaxOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPOLYAX",
57126ea1 6962 outputCabsPOLYAX, medPOLYAX);
6963
1c5895a3 6964 polyaxOutputCabs->SetVisibility(kTRUE);
6965 polyaxOutputCabs->SetLineColor(34); //
6966 polyaxOutputCabs->SetLineWidth(1);
6967 polyaxOutputCabs->SetFillColor(polyaxOutputCabs->GetLineColor());
6968 polyaxOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6969
21ea473f 6970 TGeoVolume *cuPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsCu",
57126ea1 6971 pcbBoardsCu, medCu);
6972
21ea473f 6973 cuPCBBoards->SetVisibility(kTRUE);
6974 cuPCBBoards->SetLineColor(kBlack); // Black
6975 cuPCBBoards->SetLineWidth(1);
6976 cuPCBBoards->SetFillColor(cuPCBBoards->GetLineColor());
6977 cuPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6978
21ea473f 6979 TGeoVolume *epoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsEpoxy",
57126ea1 6980 pcbBoardsEpoxy, medEpoxy);
6981
21ea473f 6982 epoxyPCBBoards->SetVisibility(kTRUE);
6983 epoxyPCBBoards->SetLineColor(22); //
6984 epoxyPCBBoards->SetLineWidth(1);
6985 epoxyPCBBoards->SetFillColor(epoxyPCBBoards->GetLineColor());
6986 epoxyPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6987
21ea473f 6988 TGeoVolume *plastPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPlast",
57126ea1 6989 pcbBoardsPlast, medPUR);
6990
21ea473f 6991 plastPCBBoards->SetVisibility(kTRUE);
6992 plastPCBBoards->SetLineColor(kRed); // Red
6993 plastPCBBoards->SetLineWidth(1);
6994 plastPCBBoards->SetFillColor(plastPCBBoards->GetLineColor());
6995 plastPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6996
21ea473f 6997 TGeoVolume *steelPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsSteel",
57126ea1 6998 pcbBoardsSteel, medSteel);
6999
21ea473f 7000 steelPCBBoards->SetVisibility(kTRUE);
7001 steelPCBBoards->SetLineColor(kBlue); // Blue
7002 steelPCBBoards->SetLineWidth(1);
7003 steelPCBBoards->SetFillColor(steelPCBBoards->GetLineColor());
7004 steelPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 7005
1c5895a3 7006 TGeoVolume *ppsPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPPS",
57126ea1 7007 pcbBoardsPPS, medPPS);
7008
1c5895a3 7009 ppsPCBBoards->SetVisibility(kTRUE);
7010 ppsPCBBoards->SetLineColor(kGreen); // Green
7011 ppsPCBBoards->SetLineWidth(1);
7012 ppsPCBBoards->SetFillColor(ppsPCBBoards->GetLineColor());
7013 ppsPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 7014
7015
7016 // Now fill the tray
7017 xloc = coolManifPOM->GetDX();
7018 yloc = 2*kSideCHalfThick + coolManifPOM->GetDY();
21ea473f 7019 trayStructure->AddNode(pomCoolManif, 1,
57126ea1 7020 new TGeoTranslation( xloc, yloc, 0) );
7021
7022 yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
21ea473f 7023 trayStructure->AddNode(steelCoolManif, 1,
57126ea1 7024 new TGeoTranslation( xloc, yloc, 0) );
7025
7026 yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
21ea473f 7027 trayStructure->AddNode(waterCoolManif, 1,
57126ea1 7028 new TGeoTranslation( xloc, yloc, 0) );
7029
7030 yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
21ea473f 7031 trayStructure->AddNode(alCoolManif, 1,
57126ea1 7032 new TGeoTranslation( xloc, yloc, 0) );
7033
7034 xloc = inputCabsCu->GetDX();
7035 yloc += coolManifWater->GetDY() + inputCabsCu->GetDY()
7036 + kSideCInputCablesTrans;
21ea473f 7037 trayStructure->AddNode(cuInputCabs, 1,
57126ea1 7038 new TGeoTranslation( xloc, yloc, 0) );
7039
7040 yloc += inputCabsCu->GetDY() + inputCabsPlast->GetDY();
21ea473f 7041 trayStructure->AddNode(plastInputCabs, 1,
57126ea1 7042 new TGeoTranslation( xloc, yloc, 0) );
7043
7044 yloc += inputCabsPlast->GetDY() + inputCabsAl->GetDY();
21ea473f 7045 trayStructure->AddNode(alInputCabs, 1,
57126ea1 7046 new TGeoTranslation( xloc, yloc, 0) );
7047
7048 yloc += inputCabsAl->GetDY() + inputCabsKapton->GetDY();
21ea473f 7049 trayStructure->AddNode(kaptonInputCabs, 1,
57126ea1 7050 new TGeoTranslation( xloc, yloc, 0) );
7051
7052 yloc += inputCabsKapton->GetDY() + inputCabsPOLYAX->GetDY();
1c5895a3 7053 trayStructure->AddNode(polyaxInputCabs, 1,
57126ea1 7054 new TGeoTranslation( xloc, yloc, 0) );
7055
21ea473f 7056 trayStructure->AddNode(purCoolTubes , 1, 0);
7057 trayStructure->AddNode(waterCoolTubes, 1, 0);
7058 trayStructure->AddNode(airCoolTubes , 1, 0);
57126ea1 7059
7060 xloc = optConnPBT->GetDX();
7061 yloc = 2*kSideCHalfThick + optConnPBT->GetDY();
7062 zloc = coolManifPOM->GetDZ() + optConnPBT->GetDZ();
21ea473f 7063 trayStructure->AddNode(pbtOptConn, 1,
57126ea1 7064 new TGeoTranslation( xloc, yloc, zloc) );
21ea473f 7065 trayStructure->AddNode(pbtOptConn, 2,
57126ea1 7066 new TGeoTranslation( xloc, yloc,-zloc) );
7067
7068 yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
21ea473f 7069 trayStructure->AddNode(steelOptConn, 1,
57126ea1 7070 new TGeoTranslation( xloc, yloc, zloc) );
21ea473f 7071 trayStructure->AddNode(steelOptConn, 2,
57126ea1 7072 new TGeoTranslation( xloc, yloc,-zloc) );
7073
7074 yloc += optConnSteel->GetDY() + optConnAl->GetDY();
21ea473f 7075 trayStructure->AddNode(alOptConn, 1,
57126ea1 7076 new TGeoTranslation( xloc, yloc, zloc) );
21ea473f 7077 trayStructure->AddNode(alOptConn, 2,
57126ea1 7078 new TGeoTranslation( xloc, yloc,-zloc) );
7079
21ea473f 7080 trayStructure->AddNode(optFibs, 1,
57126ea1 7081 new TGeoTranslation( 0, 0, zloc) );
21ea473f 7082 trayStructure->AddNode(optFibs, 2,
57126ea1 7083 new TGeoTranslation( 0, 0,-zloc) );
7084
21ea473f 7085 trayStructure->AddNode(cuOutputCabs , 1, 0);
7086 trayStructure->AddNode(plastOutputCabs , 1, 0);
7087 trayStructure->AddNode(alOutputCabs , 1, 0);
7088 trayStructure->AddNode(kaptonOutputCabs, 1, 0);
1c5895a3 7089 trayStructure->AddNode(polyaxOutputCabs, 1, 0);
57126ea1 7090
7091 xloc = kXShiftBarCool + kBarCoolRmax + pcbBoardsCu->GetDX();
7092 yloc = outputCabsPOLYAX->GetY(5) + pcbBoardsCu->GetDY();
21ea473f 7093 trayStructure->AddNode(cuPCBBoards, 1,
57126ea1 7094 new TGeoTranslation( xloc, yloc , 0) );
7095
7096 yloc += pcbBoardsCu->GetDY() + pcbBoardsEpoxy->GetDY();
21ea473f 7097 trayStructure->AddNode(epoxyPCBBoards, 1,
57126ea1 7098 new TGeoTranslation( xloc, yloc , 0) );
7099
7100 yloc += pcbBoardsEpoxy->GetDY() + pcbBoardsPlast->GetDY();
21ea473f 7101 trayStructure->AddNode(plastPCBBoards, 1,
57126ea1 7102 new TGeoTranslation( xloc, yloc , 0) );
7103
7104 yloc += pcbBoardsPlast->GetDY() + pcbBoardsSteel->GetDY();
21ea473f 7105 trayStructure->AddNode(steelPCBBoards, 1,
57126ea1 7106 new TGeoTranslation( xloc, yloc , 0) );
7107
7108 yloc += pcbBoardsSteel->GetDY() + pcbBoardsPPS->GetDY();
1c5895a3 7109 trayStructure->AddNode(ppsPCBBoards, 1,
57126ea1 7110 new TGeoTranslation( xloc, yloc , 0) );
7111
aa177c73 7112
7113 // Finally put everything in the mother volume
7114 alphafold = kSideCFoldAngle;
7115
7116 for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
7117 alpharot = kTraySideCAlphaRot[jt];
7118 xloc = kTraySideCRPos*SinD(alpharot);
7119 yloc = kTraySideCRPos*CosD(alpharot);
57126ea1 7120 moth->AddNode(trayStructure,jt+1,
aa177c73 7121 new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
7122 new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
7123 }
7124
7125
7126 return;
7127}
7128
7129
798b4e0c 7130//______________________________________________________________________
7131void AliITSv11GeometrySupport::SSDCableTraysSideA(TGeoVolume *moth,
43aefea7 7132 const TGeoManager *mgr){
798b4e0c 7133//
7134// Creates the SSD cable trays which are outside the ITS support cones
7135// but still inside the TPC on Side A
7136// (part of this code is taken or anyway inspired to ServicesCableSupport
7137// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
7138//
7139// Input:
7140// moth : the TGeoVolume owing the volume structure
7141// mgr : the GeoManager (default gGeoManager)
7142// Output:
7143//
7144// Created: ??? Bjorn S. Nilsen
7145// Updated: 30 Dec 2009 Mario Sitta
7146//
7147// Technical data are taken from AutoCAD drawings, L.Simonetti technical
7148// drawings and other (oral) information given by F.Tosello and
7149// Ton van den Brink
7150// Cables and cooling tubes are approximated with proper materials and
7151// rectangular cross sections, always preserving the total material budget.
7152//
7153
7154 // Dimensions and positions of the A-Side Cable Trays
7155 // (parts of 0872/G/D)
573a206f 7156 const Double_t kTrayARTrans = 408.35 *fgkmm;
798b4e0c 7157 const Double_t kTrayAZTrans = 1011.00 *fgkmm;
7158 const Double_t kForwardSideYTrans = 12.00 *fgkmm;//!!!TO BE CHECKED!!!
7159 const Double_t kCoversYTrans = 2.00 *fgkmm;
7160 const Double_t kTrayAZRot = (180-169.5);// Degrees
7161 const Double_t kTrayAFirstRotAng = 22.00; // Degrees
7162 const Double_t kTrayASecondRotAng = 15.00; // Degrees
7163
7164 const Double_t kTrayTotalHeight = 52.00 *fgkmm;
7165 const Double_t kTrayHeighToBend = 32.00 *fgkmm;
7166 const Double_t kTrayWidth = 130.00 *fgkmm;
7167 const Double_t kTrayThick = 2.00 *fgkmm;
7168
7169 const Double_t kTrayBendAngle = 22.00 *TMath::DegToRad();
7170
7171 const Double_t kForwardTrayTotalLen = 853.00 *fgkmm;
7172 const Double_t kForwardTrayFirstLen = 350.00 *fgkmm;
7173 const Double_t kForwardTrayFirstHeight = 47.00 *fgkmm;
7174 const Double_t kForwardCoverLen = 420.00 *fgkmm;
7175
7176 const Double_t kForwardSideLength = kForwardTrayFirstLen;//!!!TO BE CHECKED!!!
7177 const Double_t kForwardSideHeight = 90.00 *fgkmm;//!!!TO BE CHECKED!!!
7178 const Double_t kForwardSideThick = 1.00 *fgkmm;//!!!TO BE CHECKED!!!
7179 const Double_t kForwardCoverHeight = 10.00 *fgkmm;//!!!TO BE CHECKED!!!
7180
7181 const Double_t kExternalTrayTotalLen = 1200.00 *fgkmm;
7182 const Double_t kExternalCoverLen = kExternalTrayTotalLen;
7183 const Double_t kExternalCoverThick = 5.00 *fgkmm;
7184
7185 const Int_t kForwardTrayNpoints = 16;
7186
7187 const Double_t kServicesWidth = 100.00 *fgkmm;
7188 const Double_t kCopperHeight = 11.20 *fgkmm;// 1120 mm^2
7189 const Double_t kCablePlasticHeight = 11.50 *fgkmm;// 1150 mm^2
7190 const Double_t kCoolingWaterHeight = 2.65 *fgkmm;// 265 mm^2
7191 const Double_t kPoliUrethaneHeight = 4.62 *fgkmm;// 462 mm^2
7192
7193
7194 // Local variables
7195 Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
7196 Double_t xloc, yloc, zloc, alpharot, totalhi;
7197
7198
7199 // The two tray components as assemblies
573a206f 7200 TGeoVolumeAssembly *cableTrayAForw =
7201 new TGeoVolumeAssembly("ITSsupportSSDTrayAForw");
798b4e0c 7202 TGeoVolumeAssembly *cableTrayAExt =
7203 new TGeoVolumeAssembly("ITSsupportSSDTrayAExt");
7204
7205
7206 // First create all needed shapes
7207
7208 // The first part of the forward tray (part of 0872/G/D/07): a Xtru
7209 TGeoXtru *forwTrayPart1 = new TGeoXtru(2);
7210
7211 xprof[3] = kTrayWidth/2;
7212 yprof[3] = kForwardTrayFirstHeight;
7213 xprof[2] = xprof[3] - kTrayThick;
7214 yprof[2] = yprof[3];
7215 xprof[4] = xprof[3];
7216 yprof[4] = kTrayTotalHeight - kTrayHeighToBend;
7217 xprof[5] = xprof[4] - yprof[4]*TMath::Tan(kTrayBendAngle);
7218 yprof[5] = 0;
7219
7220 InsidePoint( xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
7221 -kTrayThick, xprof[1], yprof[1]);
7222
7223 xprof[6] = -xprof[5];
7224 yprof[6] = yprof[5];
7225
7226 InsidePoint( xprof[4], yprof[4], xprof[5], yprof[5], xprof[6], yprof[6],
7227 -kTrayThick, xprof[0], yprof[0]);
7228
7229 // We did the right side, now reflex on the left side
7230 for (Int_t jp = 0; jp < 6; jp++) {
7231 xprof[6+jp] = -xprof[5-jp];
7232 yprof[6+jp] = yprof[5-jp];
7233 }
7234
7235 // And now the actual Xtru
7236 forwTrayPart1->DefinePolygon(12, xprof, yprof);
7237 forwTrayPart1->DefineSection(0, 0);
7238 forwTrayPart1->DefineSection(1, kForwardTrayFirstLen);
7239
7240 // The second part of the forward tray (part of 0872/G/D/07): a Xtru
7241 TGeoXtru *forwTrayPart2 =
7242 CreateSDDSSDTraysSideA(kForwardTrayTotalLen - kForwardTrayFirstLen,
7243 kTrayTotalHeight);
7244
7245 // The external tray (as 0872/G/D/03): a Xtru with same profile
7246 TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternalTrayTotalLen,
7247 kTrayTotalHeight);
7248
7249 // The side wall of the forward tray: a BBox
7250 TGeoBBox *forwSide = new TGeoBBox(kForwardSideThick/2,
7251 kForwardSideHeight/2,
7252 kForwardSideLength/2);
7253
7254 // The side cover over the walls: a Xtru
7255 TGeoXtru *forwSideCover = new TGeoXtru(2);
7256 forwSideCover->SetName("ITSsuppSSDForwCover");
7257
7258 xprof[0] = kTrayWidth/2 + 2*kForwardSideThick;
7259 yprof[0] = kForwardCoverHeight;
7260 xprof[1] = xprof[0];
7261 yprof[1] = 0;
7262 xprof[2] = xprof[1] - kForwardSideThick;
7263 yprof[2] = yprof[1];
7264 xprof[3] = xprof[2];
7265 yprof[3] = yprof[0] - kForwardSideThick;
7266
7267 // We did the right side, now reflex on the left side
7268 for (Int_t jp = 0; jp < 4; jp++) {
7269 xprof[4+jp] = -xprof[3-jp];
7270 yprof[4+jp] = yprof[3-jp];
7271 }
7272
7273 forwSideCover->DefinePolygon(8, xprof, yprof);
7274 forwSideCover->DefineSection(0, 0);
7275 forwSideCover->DefineSection(1, kForwardSideLength);
7276
7277 // The forward and external covers: two Composite Shape's
7278 TGeoCompositeShape *forwardCover = CreateTrayAForwardCover(kForwardCoverLen);
7279
7280 TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternalCoverLen);
7281
7282 // The cable copper inside the forward tray: a BBox
7283 TGeoBBox *forwCopper = new TGeoBBox(kServicesWidth/2,
7284 kCopperHeight/2,
7285 kForwardTrayTotalLen/2);
7286
7287 // The cable copper inside the forward tray: a Xtru
7288 TGeoXtru *extCopper = new TGeoXtru(2);
7289 extCopper->SetName("ITSsuppSSDExtTrayCopper");
7290
7291 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
7292 - kTrayThick;
7293
7294 xprof[0] = -totalhi*TanD(kTrayAZRot);
7295 yprof[0] = kTrayThick;
7296 xprof[1] = kExternalTrayTotalLen;
7297 yprof[1] = yprof[0];
7298 xprof[2] = xprof[1];
7299 yprof[2] = yprof[1] + kCopperHeight;
7300 totalhi -= kCopperHeight;
7301 xprof[3] = -totalhi*TanD(kTrayAZRot);
7302 yprof[3] = yprof[2];
7303
7304 extCopper->DefinePolygon(4, xprof, yprof);
7305 extCopper->DefineSection(0, 0);
7306 extCopper->DefineSection(1, kServicesWidth);
7307
7308 // The cable plastic inside the forward tray: a BBox
7309 TGeoBBox *forwPlastic = new TGeoBBox(kServicesWidth/2,
7310 kCablePlasticHeight/2,
7311 kForwardTrayTotalLen/2);
7312
7313 // The cable plastic inside the forward tray: a Xtru
7314 TGeoXtru *extPlastic = new TGeoXtru(2);
7315 extPlastic->SetName("ITSsuppSSDExtTrayPlastic");
7316
7317 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
7318 - kTrayThick - kCopperHeight;
7319
7320 xprof[0] = -totalhi*TanD(kTrayAZRot);
7321 yprof[0] = kTrayThick;
7322 xprof[1] = kExternalTrayTotalLen;
7323 yprof[1] = yprof[0];
7324 xprof[2] = xprof[1];
7325 yprof[2] = yprof[1] + kCablePlasticHeight;
7326 totalhi -= kCablePlasticHeight;
7327 xprof[3] = -totalhi*TanD(kTrayAZRot);
7328 yprof[3] = yprof[2];
7329
7330 extPlastic->DefinePolygon(4, xprof, yprof);
7331 extPlastic->DefineSection(0, 0);
7332 extPlastic->DefineSection(1, kServicesWidth);
7333
7334 // The cooling water inside the forward tray: a BBox
7335 TGeoBBox *forwWater = new TGeoBBox(kServicesWidth/2,
7336 kCoolingWaterHeight/2,
7337 kForwardTrayTotalLen/2);
7338
7339 // The cooling water inside the forward tray: a Xtru
7340 TGeoXtru *extWater = new TGeoXtru(2);
7341 extWater->SetName("ITSsuppSSDExtTrayWater");
7342
7343 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
7344 - kTrayThick - kCopperHeight - kCablePlasticHeight;
7345
7346 xprof[0] = -totalhi*TanD(kTrayAZRot);
7347 yprof[0] = kTrayThick;
7348 xprof[1] = kExternalTrayTotalLen;
7349 yprof[1] = yprof[0];
7350 xprof[2] = xprof[1];
7351 yprof[2] = yprof[1] + kCoolingWaterHeight;
7352 totalhi -= kCoolingWaterHeight;
7353 xprof[3] = -totalhi*TanD(kTrayAZRot);
7354 yprof[3] = yprof[2];
7355
7356 extWater->DefinePolygon(4, xprof, yprof);
7357 extWater->DefineSection(0, 0);
7358 extWater->DefineSection(1, kServicesWidth);
7359
7360 // The polyurethane inside the forward tray: a BBox
7361 TGeoBBox *forwPUR = new TGeoBBox(kServicesWidth/2,
7362 kPoliUrethaneHeight/2,
7363 kForwardTrayTotalLen/2);
7364
7365 // The poliurethane inside the forward tray: a Xtru
7366 TGeoXtru *extPUR = new TGeoXtru(2);
7367 extPUR->SetName("ITSsuppSSDExtTrayPUR");
7368
7369 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
7370 - kTrayThick - kCopperHeight - kCablePlasticHeight
7371 - kCoolingWaterHeight;
7372
7373 xprof[0] = -totalhi*TanD(kTrayAZRot);
7374 yprof[0] = kTrayThick;
7375 xprof[1] = kExternalTrayTotalLen;
7376 yprof[1] = yprof[0];
7377 xprof[2] = xprof[1];
7378 yprof[2] = yprof[1] + kPoliUrethaneHeight;
7379 totalhi -= kPoliUrethaneHeight;
7380 xprof[3] = -totalhi*TanD(kTrayAZRot);
7381 yprof[3] = yprof[2];
7382
7383 extPUR->DefinePolygon(4, xprof, yprof);
7384 extPUR->DefineSection(0, 0);
7385 extPUR->DefineSection(1, kServicesWidth);
7386
7387
7388 // We have all shapes: now create the real volumes
0801d201 7389 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
798b4e0c 7390 TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
0801d201 7391 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
798b4e0c 7392 TGeoMedium *medFEP = mgr->GetMedium("ITS_SSD FEP$");
0801d201 7393 TGeoMedium *medH2O = mgr->GetMedium("ITS_WATER$");
7394 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
798b4e0c 7395
7396 TGeoVolume *forwTrayFirst = new TGeoVolume("ITSsuppSSDSideAForwTrayFirst",
7397 forwTrayPart1, medAl);
7398
7399 forwTrayFirst->SetVisibility(kTRUE);
7400 forwTrayFirst->SetLineColor(6); // Purple
7401 forwTrayFirst->SetLineWidth(1);
7402 forwTrayFirst->SetFillColor(forwTrayFirst->GetLineColor());
7403 forwTrayFirst->SetFillStyle(4000); // 0% transparent
7404
7405 TGeoVolume *forwTraySecond = new TGeoVolume("ITSsuppSSDSideAForwTraySecond",
7406 forwTrayPart2, medAl);
7407
7408 forwTraySecond->SetVisibility(kTRUE);
7409 forwTraySecond->SetLineColor(6); // Purple
7410 forwTraySecond->SetLineWidth(1);
7411 forwTraySecond->SetFillColor(forwTraySecond->GetLineColor());
7412 forwTraySecond->SetFillStyle(4000); // 0% transparent
7413
7414 TGeoVolume *forwTraySide = new TGeoVolume("ITSsuppSSDSideAForwTraySide",
7415 forwSide, medAl);
7416
7417 forwTraySide->SetVisibility(kTRUE);
7418 forwTraySide->SetLineColor(6); // Purple
7419 forwTraySide->SetLineWidth(1);
7420 forwTraySide->SetFillColor(forwTraySide->GetLineColor());
7421 forwTraySide->SetFillStyle(4000); // 0% transparent
7422
7423 TGeoVolume *forwTraySideCover = new TGeoVolume("ITSsuppSSDSideAForwTraySideCover",
7424 forwSideCover, medAl);
7425
7426 forwTraySideCover->SetVisibility(kTRUE);
7427 forwTraySideCover->SetLineColor(6); // Purple
7428 forwTraySideCover->SetLineWidth(1);
7429 forwTraySideCover->SetFillColor(forwTraySideCover->GetLineColor());
7430 forwTraySideCover->SetFillStyle(4000); // 0% transparent
7431
7432 TGeoVolume *externalTraySSD = new TGeoVolume("ITSsuppSSDSideAExternalTray",
7433 externalTray, medAl);
7434
7435 externalTraySSD->SetVisibility(kTRUE);
7436 externalTraySSD->SetLineColor(6); // Purple
7437 externalTraySSD->SetLineWidth(1);
7438 externalTraySSD->SetFillColor(externalTraySSD->GetLineColor());
7439 externalTraySSD->SetFillStyle(4000); // 0% transparent
7440
7441 TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSSDSideAForwTrayCover",
7442 forwardCover, medAntic);
7443
7444 forwardTrayCover->SetVisibility(kTRUE);
7445 forwardTrayCover->SetLineColor(kMagenta+1); // Purple
7446 forwardTrayCover->SetLineWidth(1);
7447 forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
7448 forwardTrayCover->SetFillStyle(4000); // 0% transparent
7449
7450 TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSSDSideAExtTrayCover",
7451 externCover, medAntic);
7452
7453 externTrayCover->SetVisibility(kTRUE);
7454 externTrayCover->SetLineColor(kMagenta+1); // Purple
7455 externTrayCover->SetLineWidth(1);
7456 externTrayCover->SetFillColor(externTrayCover->GetLineColor());
7457 externTrayCover->SetFillStyle(4000); // 0% transparent
7458
7459 TGeoVolume *forwCableCu = new TGeoVolume("ITSsuppSSDSideAForwCableCu",
7460 forwCopper, medCu);
7461
7462 forwCableCu->SetVisibility(kTRUE);
7463 forwCableCu->SetLineColor(kRed); // Red
7464 forwCableCu->SetLineWidth(1);
7465 forwCableCu->SetFillColor(forwCableCu->GetLineColor());
7466 forwCableCu->SetFillStyle(4000); // 0% transparent
7467
7468 TGeoVolume *extCableCu = new TGeoVolume("ITSsuppSSDSideAExtCableCu",
7469 extCopper, medCu);
7470
7471 extCableCu->SetVisibility(kTRUE);
7472 extCableCu->SetLineColor(kRed); // Red
7473 extCableCu->SetLineWidth(1);
7474 extCableCu->SetFillColor(extCableCu->GetLineColor());
7475 extCableCu->SetFillStyle(4000); // 0% transparent
7476
7477 TGeoVolume *forwCableFEP = new TGeoVolume("ITSsuppSSDSideAForwCableFEP",
7478 forwPlastic, medFEP);
7479
7480 forwCableFEP->SetVisibility(kTRUE);
7481 forwCableFEP->SetLineColor(kYellow); // Yellow
7482 forwCableFEP->SetLineWidth(1);
7483 forwCableFEP->SetFillColor(forwCableFEP->GetLineColor());
7484 forwCableFEP->SetFillStyle(4000); // 0% transparent
7485
7486 TGeoVolume *extCableFEP = new TGeoVolume("ITSsuppSSDSideAExtCableFEP",
7487 extPlastic, medFEP);
7488
7489 extCableFEP->SetVisibility(kTRUE);
7490 extCableFEP->SetLineColor(kYellow); // Yellow
7491 extCableFEP->SetLineWidth(1);
7492 extCableFEP->SetFillColor(extCableFEP->GetLineColor());
7493 extCableFEP->SetFillStyle(4000); // 0% transparent
7494
7495 TGeoVolume *forwTrayWater = new TGeoVolume("ITSsuppSSDSideAForwTrayWater",
7496 forwWater, medH2O);
7497
7498 forwTrayWater->SetVisibility(kTRUE);
7499 forwTrayWater->SetLineColor(kBlue); // Blue
7500 forwTrayWater->SetLineWidth(1);
7501 forwTrayWater->SetFillColor(forwTrayWater->GetLineColor());
7502 forwTrayWater->SetFillStyle(4000); // 0% transparent
7503
7504 TGeoVolume *extTrayWater = new TGeoVolume("ITSsuppSSDSideAExtTrayWater",
7505 extWater, medH2O);
7506
7507 extTrayWater->SetVisibility(kTRUE);
7508 extTrayWater->SetLineColor(kBlue); // Blue
7509 extTrayWater->SetLineWidth(1);
7510 extTrayWater->SetFillColor(extTrayWater->GetLineColor());
7511 extTrayWater->SetFillStyle(4000); // 0% transparent
7512
7513 TGeoVolume *forwPolyUr = new TGeoVolume("ITSsuppSSDSideAForwPolyUr",
7514 forwPUR, medPUR);
7515
7516 forwPolyUr->SetVisibility(kTRUE);
7517 forwPolyUr->SetLineColor(kGray); // Gray
7518 forwPolyUr->SetLineWidth(1);
7519 forwPolyUr->SetFillColor(forwPolyUr->GetLineColor());
7520 forwPolyUr->SetFillStyle(4000); // 0% transparent
7521
7522 TGeoVolume *extPolyUr = new TGeoVolume("ITSsuppSSDSideAExtPolyUr",
7523 extPUR, medPUR);
7524
7525 extPolyUr->SetVisibility(kTRUE);
7526 extPolyUr->SetLineColor(kGray); // Gray
7527 extPolyUr->SetLineWidth(1);
7528 extPolyUr->SetFillColor(extPolyUr->GetLineColor());
7529 extPolyUr->SetFillStyle(4000); // 0% transparent
7530
7531
7532 // Now build up the tray
573a206f 7533 cableTrayAForw->AddNode(forwTrayFirst, 1, 0);
798b4e0c 7534
573a206f 7535 cableTrayAForw->AddNode(forwTraySecond, 1,
798b4e0c 7536 new TGeoTranslation(0, 0, kForwardTrayFirstLen) );
7537
7538 xloc = kTrayWidth/2 + kForwardSideThick/2;
7539 yloc = kForwardTrayFirstHeight + kForwardSideHeight/2 - kForwardSideYTrans;
7540 zloc = kForwardSideLength/2;
573a206f 7541 cableTrayAForw->AddNode(forwTraySide,1,
798b4e0c 7542 new TGeoTranslation( xloc, yloc, zloc) );
573a206f 7543 cableTrayAForw->AddNode(forwTraySide,2,
798b4e0c 7544 new TGeoTranslation(-xloc, yloc, zloc) );
7545
7546 yloc = kForwardTrayFirstHeight + kForwardSideHeight - kForwardSideYTrans
7547 - kForwardCoverHeight;
573a206f 7548 cableTrayAForw->AddNode(forwTraySideCover,1,
798b4e0c 7549 new TGeoTranslation(0, yloc, 0) );
7550
7551 yloc = kTrayTotalHeight - kCoversYTrans;
7552 zloc = kForwardTrayTotalLen - kForwardCoverLen;
573a206f 7553 cableTrayAForw->AddNode(forwardTrayCover,1,
798b4e0c 7554 new TGeoTranslation(0, yloc, zloc) );
7555
7556 yloc = kTrayThick + forwCopper->GetDY();
7557 zloc = forwCopper->GetDZ();
573a206f 7558 cableTrayAForw->AddNode(forwCableCu, 1,
798b4e0c 7559 new TGeoTranslation(0, yloc, zloc) );
7560
7561 yloc = kTrayThick + kCopperHeight + forwPlastic->GetDY();
7562 zloc = forwPlastic->GetDZ();
573a206f 7563 cableTrayAForw->AddNode(forwCableFEP, 1,
798b4e0c 7564 new TGeoTranslation(0, yloc, zloc) );
7565
7566 yloc = kTrayThick + kCopperHeight + kCablePlasticHeight + forwWater->GetDY();
7567 zloc = forwWater->GetDZ();
573a206f 7568 cableTrayAForw->AddNode(forwTrayWater, 1,
798b4e0c 7569 new TGeoTranslation(0, yloc, zloc) );
7570
7571 yloc = kTrayThick + kCopperHeight + kCablePlasticHeight
7572 + kCoolingWaterHeight + forwPUR->GetDY();
7573 zloc = forwPUR->GetDZ();
573a206f 7574 cableTrayAForw->AddNode(forwPolyUr, 1,
798b4e0c 7575 new TGeoTranslation(0, yloc, zloc) );
7576
7577 // To simplify following placement in MARS, origin is on top
7578 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans;
7579
7580 yloc = -totalhi;
7581 cableTrayAExt->AddNode(externalTraySSD, 1,
7582 new TGeoTranslation(0, yloc, 0) );
7583
7584 yloc = -totalhi + kTrayTotalHeight - kCoversYTrans;
7585 cableTrayAExt->AddNode(externTrayCover,1,
7586 new TGeoTranslation(0, yloc, 0) );
7587
7588 xloc = extCopper->GetDZ();
7589 yloc = -totalhi;
7590 cableTrayAExt->AddNode(extCableCu,1,
7591 new TGeoCombiTrans( xloc, yloc, 0,
7592 new TGeoRotation("",-90, 90, 90) ) );
7593
7594 xloc = extPlastic->GetDZ();
7595 yloc = -totalhi + kCopperHeight;
7596 cableTrayAExt->AddNode(extCableFEP,1,
7597 new TGeoCombiTrans( xloc, yloc, 0,
7598 new TGeoRotation("",-90, 90, 90) ) );
7599
7600 xloc = extWater->GetDZ();
7601 yloc = -totalhi + kCopperHeight + kCablePlasticHeight;
7602 cableTrayAExt->AddNode(extTrayWater,1,
7603 new TGeoCombiTrans( xloc, yloc, 0,
7604 new TGeoRotation("",-90, 90, 90) ) );
7605
7606 xloc = extPUR->GetDZ();
7607 yloc = -totalhi + kCopperHeight + kCablePlasticHeight + kCoolingWaterHeight;
7608 cableTrayAExt->AddNode(extPolyUr,1,
7609 new TGeoCombiTrans( xloc, yloc, 0,
7610 new TGeoRotation("",-90, 90, 90) ) );
7611
7612
7613 // Finally put everything in the mother volume
7614 zloc = kTrayAZTrans;
7615 Double_t zlocext = zloc + kForwardTrayTotalLen;
7616 Double_t rExtTray = kTrayARTrans + kTrayTotalHeight;
7617
7618 alpharot = kTrayAFirstRotAng;
7619 xloc = kTrayARTrans*SinD(alpharot);
7620 yloc = kTrayARTrans*CosD(alpharot);
573a206f 7621 moth->AddNode(cableTrayAForw,1,
798b4e0c 7622 new TGeoCombiTrans( xloc, yloc, zloc,
7623 new TGeoRotation("",-alpharot,0,0) ) );
7624 xloc = rExtTray*SinD(alpharot);
7625 yloc = rExtTray*CosD(alpharot);
7626 moth->AddNode(cableTrayAExt,1,
7627 new TGeoCombiTrans( xloc, yloc, zlocext,
7628 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
7629
7630 alpharot += 180;
7631 xloc = kTrayARTrans*SinD(alpharot);
7632 yloc = kTrayARTrans*CosD(alpharot);
573a206f 7633 moth->AddNode(cableTrayAForw,2,
798b4e0c 7634 new TGeoCombiTrans( xloc, yloc, zloc,
7635 new TGeoRotation("",-alpharot,0,0) ) );
7636 xloc = rExtTray*SinD(alpharot);
7637 yloc = rExtTray*CosD(alpharot);
7638 moth->AddNode(cableTrayAExt,2,
7639 new TGeoCombiTrans( xloc, yloc, zlocext,
7640 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
7641
7642 alpharot = -kTrayAFirstRotAng - 2*kTrayASecondRotAng;
7643 xloc = kTrayARTrans*SinD(alpharot);
7644 yloc = kTrayARTrans*CosD(alpharot);
573a206f 7645 moth->AddNode(cableTrayAForw,3,
798b4e0c 7646 new TGeoCombiTrans( xloc, yloc, zloc,
7647 new TGeoRotation("",-alpharot,0,0) ) );
7648 xloc = rExtTray*SinD(alpharot);
7649 yloc = rExtTray*CosD(alpharot);
7650 moth->AddNode(cableTrayAExt,3,
7651 new TGeoCombiTrans( xloc, yloc, zlocext,
7652 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
7653
7654 alpharot += 180;
7655 xloc = kTrayARTrans*SinD(alpharot);
7656 yloc = kTrayARTrans*CosD(alpharot);
573a206f 7657 moth->AddNode(cableTrayAForw,4,
798b4e0c 7658 new TGeoCombiTrans( xloc, yloc, zloc,
7659 new TGeoRotation("",-alpharot,0,0) ) );
7660 xloc = rExtTray*SinD(alpharot);
7661 yloc = rExtTray*CosD(alpharot);
7662 moth->AddNode(cableTrayAExt,4,
7663 new TGeoCombiTrans( xloc, yloc, zlocext,
7664 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
7665
7666
7667 return;
7668}
7669
aa177c73 7670//______________________________________________________________________
7671void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth,
43aefea7 7672 const TGeoManager *mgr){
aa177c73 7673//
7674// Creates the SSD cable trays which are outside the ITS support cones
7675// but still inside the TPC on Side C
7676// (part of this code is taken or anyway inspired to ServicesCableSupport
7677// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
7678//
7679// Input:
7680// moth : the TGeoVolume owing the volume structure
7681// mgr : the GeoManager (default gGeoManager)
7682// Output:
7683//
7684// Created: ??? Bjorn S. Nilsen
7685// Updated: 15 Apr 2010 Mario Sitta
7686//
7687// Technical data are taken from AutoCAD drawings and other (oral)
7688// information given by F.Tosello
7689//
7690
7691 // Dimensions and positions of the C-Side Cable Tray elements
7692 const Int_t kNumTraySideC = 4;
7693
7694 const Double_t kSideCFoldAngle = 5.00 *fgkDegree;
7695
7696 const Double_t kServicesWidth = 100.00 *fgkmm;
7697 const Double_t kCopperHeight = 11.20 *fgkmm;// 1120 mm^2
7698 const Double_t kCablePlasticHeight = 11.50 *fgkmm;// 1150 mm^2
7699 const Double_t kCoolingWaterHeight = 2.65 *fgkmm;// 265 mm^2
7700 const Double_t kPoliUrethaneHeight = 4.62 *fgkmm;// 462 mm^2
5d9d4033 7701 const Double_t kCablesYtrans = 2.50 *fgkmm;// Avoid ovlps
aa177c73 7702
7703 // Overall position and rotation of the C-Side Cable Trays
7704 const Double_t kTraySideCRPos = 45.30 *fgkcm;
7705 const Double_t kTraySideCZPos = -102.40 *fgkcm;
7706 const Double_t kTraySideCAlphaRot[kNumTraySideC] = { 23.0, -59.0,
7707 /* from Patch panel position */ 180.+23.0, 180.-59.0};
7708
7709
7710 // Local variables
7711 Double_t xprof[6], yprof[6];
7712 Double_t xloc, yloc, alpharot, alphafold;
7713
7714
7715 // The assembly holding the metallic structure
7716 TGeoVolumeAssembly *trayStructure =
7717 CreateSDDSSDTraysSideC("ITSsupportSSDTrayC");
7718
7719 // The cable copper inside the tray: a Xtru
7720 TGeoXtru *copper = new TGeoXtru(2);
7721 copper->SetName("ITSsuppSSDTrayCCopper");
7722
7723 // Copper lies on the lower plate: get position of its points
7724 TGeoXtru *lowerplate = (TGeoXtru*)(mgr->GetVolume("ITSsuppTraySideCLower")->GetShape());
7725 xprof[0] = lowerplate->GetX(5);
5d9d4033 7726 yprof[0] = lowerplate->GetY(5) + kCablesYtrans;
aa177c73 7727 xprof[1] = lowerplate->GetX(4);
5d9d4033 7728 yprof[1] = lowerplate->GetY(4) + kCablesYtrans;
aa177c73 7729 xprof[2] = lowerplate->GetX(3);
5d9d4033 7730 yprof[2] = lowerplate->GetY(3) + kCablesYtrans;
aa177c73 7731 xprof[3] = xprof[2] - kCopperHeight*SinD(kSideCFoldAngle);
7732 yprof[3] = yprof[2] + kCopperHeight*CosD(kSideCFoldAngle);
7733 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7734 kCopperHeight , xprof[4], yprof[4]);
7735 xprof[5] = xprof[0];
7736 yprof[5] = yprof[0] + kCopperHeight;
7737
7738 copper->DefinePolygon(6, xprof, yprof);
7739 copper->DefineSection(0, -kServicesWidth/2);
7740 copper->DefineSection(1, kServicesWidth/2);
7741
7742 // The cable plastic inside the tray: a Xtru
7743 TGeoXtru *plastic = new TGeoXtru(2);
7744 plastic->SetName("ITSsuppSSDTrayCPlastic");
7745
7746 xprof[0] = copper->GetX(5);
7747 yprof[0] = copper->GetY(5);
7748 xprof[1] = copper->GetX(4);
7749 yprof[1] = copper->GetY(4);
7750 xprof[2] = copper->GetX(3);
7751 yprof[2] = copper->GetY(3);
7752 xprof[3] = xprof[2] - kCablePlasticHeight*SinD(kSideCFoldAngle);
7753 yprof[3] = yprof[2] + kCablePlasticHeight*CosD(kSideCFoldAngle);
7754 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7755 kCablePlasticHeight , xprof[4], yprof[4]);
7756 xprof[5] = xprof[0];
7757 yprof[5] = yprof[0] + kCablePlasticHeight;
7758
7759 plastic->DefinePolygon(6, xprof, yprof);
7760 plastic->DefineSection(0, -kServicesWidth/2);
7761 plastic->DefineSection(1, kServicesWidth/2);
7762
7763 // The cooling water inside the tray: a Xtru
7764 TGeoXtru *water = new TGeoXtru(2);
7765 water->SetName("ITSsuppSSDTrayCWater");
7766
7767 xprof[0] = plastic->GetX(5);
7768 yprof[0] = plastic->GetY(5);
7769 xprof[1] = plastic->GetX(4);
7770 yprof[1] = plastic->GetY(4);
7771 xprof[2] = plastic->GetX(3);
7772 yprof[2] = plastic->GetY(3);
7773 xprof[3] = xprof[2] - kCoolingWaterHeight*SinD(kSideCFoldAngle);
7774 yprof[3] = yprof[2] + kCoolingWaterHeight*CosD(kSideCFoldAngle);
7775 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7776 kCoolingWaterHeight , xprof[4], yprof[4]);
7777 xprof[5] = xprof[0];
7778 yprof[5] = yprof[0] + kCoolingWaterHeight;
7779
7780 water->DefinePolygon(6, xprof, yprof);
7781 water->DefineSection(0, -kServicesWidth/2);
7782 water->DefineSection(1, kServicesWidth/2);
7783
7784 // The poliurethane inside the tray: a Xtru
1c5895a3 7785 TGeoXtru *pur = new TGeoXtru(2);
7786 pur->SetName("ITSsuppSSDTrayCPUR");
aa177c73 7787 xprof[0] = water->GetX(5);
7788 yprof[0] = water->GetY(5);
7789 xprof[1] = water->GetX(4);
7790 yprof[1] = water->GetY(4);
7791 xprof[2] = water->GetX(3);
7792 yprof[2] = water->GetY(3);
7793 xprof[3] = xprof[2] - kPoliUrethaneHeight*SinD(kSideCFoldAngle);
7794 yprof[3] = yprof[2] + kPoliUrethaneHeight*CosD(kSideCFoldAngle);
7795 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7796 kPoliUrethaneHeight , xprof[4], yprof[4]);
7797 xprof[5] = xprof[0];
7798 yprof[5] = yprof[0] + kPoliUrethaneHeight;
7799
1c5895a3 7800 pur->DefinePolygon(6, xprof, yprof);
7801 pur->DefineSection(0, -kServicesWidth/2);
7802 pur->DefineSection(1, kServicesWidth/2);
aa177c73 7803
7804
7805 // We have all shapes: now create the real volumes
0801d201 7806 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
aa177c73 7807 TGeoMedium *medFEP = mgr->GetMedium("ITS_SSD FEP$");
0801d201 7808 TGeoMedium *medH2O = mgr->GetMedium("ITS_WATER$");
7809 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
aa177c73 7810
7811 TGeoVolume *copperCable = new TGeoVolume("ITSsuppSSDSideCCableCu",
7812 copper, medCu);
7813
7814 copperCable->SetVisibility(kTRUE);
7815 copperCable->SetLineColor(kRed); // Red
7816 copperCable->SetLineWidth(1);
7817 copperCable->SetFillColor(copperCable->GetLineColor());
7818 copperCable->SetFillStyle(4000); // 0% transparent
7819
7820 TGeoVolume *cableFEP = new TGeoVolume("ITSsuppSSDSideCCableFEP",
7821 plastic, medFEP);
7822
7823 cableFEP->SetVisibility(kTRUE);
7824 cableFEP->SetLineColor(kYellow); // Yellow
7825 cableFEP->SetLineWidth(1);
7826 cableFEP->SetFillColor(cableFEP->GetLineColor());
7827 cableFEP->SetFillStyle(4000); // 0% transparent
7828
7829 TGeoVolume *trayWater = new TGeoVolume("ITSsuppSSDSideCTrayWater",
7830 water, medH2O);
7831
7832 trayWater->SetVisibility(kTRUE);
7833 trayWater->SetLineColor(kBlue); // Blue
7834 trayWater->SetLineWidth(1);
7835 trayWater->SetFillColor(trayWater->GetLineColor());
7836 trayWater->SetFillStyle(4000); // 0% transparent
7837
7838 TGeoVolume *trayPolyUr = new TGeoVolume("ITSsuppSSDSideCPolyUr",
1c5895a3 7839 pur, medPUR);
aa177c73 7840
7841 trayPolyUr->SetVisibility(kTRUE);
7842 trayPolyUr->SetLineColor(kGray); // Gray
7843 trayPolyUr->SetLineWidth(1);
7844 trayPolyUr->SetFillColor(trayPolyUr->GetLineColor());
7845 trayPolyUr->SetFillStyle(4000); // 0% transparent
7846
7847
7848 // Now fill in the tray
7849 trayStructure->AddNode(copperCable,1,0);
7850 trayStructure->AddNode(cableFEP,1,0);
7851 trayStructure->AddNode(trayWater,1,0);
7852 trayStructure->AddNode(trayPolyUr,1,0);
7853
7854
7855 // Finally put everything in the mother volume
7856 alphafold = kSideCFoldAngle;
7857
7858 for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
7859 alpharot = kTraySideCAlphaRot[jt];
7860 xloc = kTraySideCRPos*SinD(alpharot);
7861 yloc = kTraySideCRPos*CosD(alpharot);
7862 moth->AddNode(trayStructure,jt+1,
7863 new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
7864 new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
7865 }
7866
7867
7868 return;
7869}
7870
798b4e0c 7871//______________________________________________________________________
57126ea1 7872void AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoVolumeAssembly *tray,
43aefea7 7873 const TGeoManager *mgr){
798b4e0c 7874//
7875// Creates the forward SDD tray on Side A (0872/G/D/01)
7876//
7877// Input:
57126ea1 7878// tray : the TGeoVolumeAssembly to put the elements in
798b4e0c 7879// mgr : the GeoManager (used only to get the proper material)
7880//
7881// Output:
7882//
57126ea1 7883// Return:
798b4e0c 7884//
7885// Created: 08 Jan 2010 Mario Sitta
57126ea1 7886// Updated: 07 Sep 2010 Mario Sitta
798b4e0c 7887//
7888// Technical data are taken from AutoCAD drawings, L.Simonetti technical
7889// drawings and other (oral) information given by F.Tosello
7890//
7891
7892 // Dimensions of the A-Side Forward Cable Tray (0872/G/D/01)
7893 const Double_t kForwardTrayThick = 2.00 *fgkmm;
7894 const Double_t kForwardTraySideLength = 823.00 *fgkmm;
7895 const Double_t kForwardTrayTailLength = 212.00 *fgkmm;
7896 const Double_t kForwardTrayBaseHalfWide = 55.00 *fgkmm;
7897 const Double_t kForwardTrayNotchLength = 47.20 *fgkmm;
7898 const Double_t kForwardTrayNotchHeight = 25.00 *fgkmm;
7899 const Double_t kForwardTrayNotchDown = 10.00 *fgkmm;
7900 const Double_t kForwardTraySide1Height = 39.00 *fgkmm;
7901 const Double_t kForwardTraySide2Height = 26.00 *fgkmm;
7902 const Double_t kForwardTraySide2Expand = 10.50 *fgkmm;
7903 const Double_t kForwardTraySide3TailLen = 418.00 *fgkmm;
7904 const Double_t kForwardTraySide3TailHi = 31.00 *fgkmm;
7905 const Double_t kForwardTraySide3HeadLen = 425.00 *fgkmm;
7906 const Double_t kForwardTraySide3HeadHi = 72.00 *fgkmm;
7907 const Double_t kForwardTrayHorWingWide = 10.50 *fgkmm;
7908 const Double_t kForwardTrayVertWingWide = 15.00 *fgkmm;
7909
7910 const Int_t kForwardTraySideNpoints = 9;
7911
7912
7913 // Local variables
7914 Double_t xprof[kForwardTraySideNpoints], yprof[kForwardTraySideNpoints];
7915 Double_t ylen, zlen;
7916 Double_t xloc, yloc, zloc;
7917
7918
7919 // The tray has a very complex shape, so it is made by assembling
57126ea1 7920 // different elements (with some small simplifications)
798b4e0c 7921
7922 // The tray base: a BBox
7923 zlen = (kForwardTraySideLength-kForwardTrayTailLength)/2;
7924 TGeoBBox *trayBase = new TGeoBBox(kForwardTrayBaseHalfWide,
7925 kForwardTrayThick/2, zlen);
7926
7927 // The first part of the side wall: a Xtru
7928 TGeoXtru *traySide1 = new TGeoXtru(2);
7929
7930 xprof[0] = 0;
7931 yprof[0] = kForwardTrayThick;
7932 xprof[1] = kForwardTraySideLength-kForwardTrayTailLength;
7933 yprof[1] = yprof[0];
7934 xprof[2] = kForwardTraySideLength;
7935 yprof[2] = kForwardTraySide1Height + kForwardTrayThick;
7936 xprof[3] = 0;
7937 yprof[3] = yprof[2];
7938
7939 traySide1->DefinePolygon(4, xprof, yprof);
7940 traySide1->DefineSection(0, 0);
7941 traySide1->DefineSection(1, kForwardTrayThick);
7942
7943 // The second part of the side wall: a Xtru
7944 TGeoXtru *traySide2 = new TGeoXtru(2);
7945
7946 xprof[0] = kForwardTrayBaseHalfWide - kForwardTrayThick;
7947 yprof[0] = traySide1->GetY(2);
7948 xprof[1] = kForwardTrayBaseHalfWide;
7949 yprof[1] = yprof[0];
7950 xprof[2] = xprof[1] + kForwardTraySide2Expand;
7951 yprof[2] = yprof[1] + kForwardTraySide2Height;
7952 xprof[3] = xprof[2] - kForwardTrayThick;
7953 yprof[3] = yprof[2];
7954
7955 traySide2->DefinePolygon(4, xprof, yprof);
7956 traySide2->DefineSection(0, 0);
7957 traySide2->DefineSection(1, kForwardTraySideLength);
7958
7959 // The third part of the side wall: a Xtru
7960 TGeoXtru *traySide3 = new TGeoXtru(2);
7961
7962 xprof[0] = 0;
7963 yprof[0] = traySide2->GetY(2);
7964 xprof[1] = kForwardTraySideLength;
7965 yprof[1] = yprof[0];
7966 xprof[2] = xprof[1];
7967 yprof[2] = yprof[1] + kForwardTraySide3TailHi - kForwardTrayThick;
7968 xprof[3] = xprof[2] - kForwardTraySide3TailLen - kForwardTrayThick;
7969 yprof[3] = yprof[2];
7970 xprof[4] = xprof[3];
7971 yprof[4] = yprof[3] + kForwardTraySide3HeadHi + kForwardTrayThick;
7972 xprof[5] = xprof[4] - kForwardTraySide3HeadLen;
7973 yprof[5] = yprof[4];
7974 xprof[6] = xprof[5];
7975 yprof[6] = yprof[5] - kForwardTrayNotchHeight;
7976 xprof[7] = xprof[6] + kForwardTrayNotchLength;
7977 yprof[7] = yprof[6];
7978 xprof[8] = xprof[7];
7979 yprof[8] = yprof[7] - kForwardTrayNotchDown;
7980
7981 traySide3->DefinePolygon(9, xprof, yprof);
7982 traySide3->DefineSection(0, 0);
7983 traySide3->DefineSection(1, kForwardTrayThick);
7984
7985 // The horizontal wing: a BBox
7986 TGeoBBox *trayHorWing = new TGeoBBox(kForwardTrayHorWingWide/2,
7987 kForwardTrayThick/2,
7988 kForwardTraySide3TailLen/2);
7989
7990 // The vertical wing: a BBox
7991 ylen = (traySide3->GetY(4) - traySide3->GetY(3))/2;
7992 TGeoBBox *trayVertWing = new TGeoBBox(kForwardTrayVertWingWide/2,
7993 ylen, kForwardTrayThick/2);
7994
7995
7996 // We have all shapes: now create the real volumes
0801d201 7997 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
798b4e0c 7998
7999 TGeoVolume *forwTrayBase = new TGeoVolume("ITSsuppSDDSideAForwTrayBase",
8000 trayBase, medAl);
8001
8002 forwTrayBase->SetVisibility(kTRUE);
8003 forwTrayBase->SetLineColor(6); // Purple
8004 forwTrayBase->SetLineWidth(1);
8005 forwTrayBase->SetFillColor(forwTrayBase->GetLineColor());
8006 forwTrayBase->SetFillStyle(4000); // 0% transparent
8007
8008 TGeoVolume *forwTraySide1 = new TGeoVolume("ITSsuppSDDSideAForwTraySide1",
8009 traySide1, medAl);
8010
8011 forwTraySide1->SetVisibility(kTRUE);
8012 forwTraySide1->SetLineColor(6); // Purple
8013 forwTraySide1->SetLineWidth(1);
8014 forwTraySide1->SetFillColor(forwTraySide1->GetLineColor());
8015 forwTraySide1->SetFillStyle(4000); // 0% transparent
8016
8017 TGeoVolume *forwTraySide2 = new TGeoVolume("ITSsuppSDDSideAForwTraySide2",
8018 traySide2, medAl);
8019
8020 forwTraySide2->SetVisibility(kTRUE);
8021 forwTraySide2->SetLineColor(6); // Purple
8022 forwTraySide2->SetLineWidth(1);
8023 forwTraySide2->SetFillColor(forwTraySide2->GetLineColor());
8024 forwTraySide2->SetFillStyle(4000); // 0% transparent
8025
8026 TGeoVolume *forwTraySide3 = new TGeoVolume("ITSsuppSDDSideAForwTraySide3",
8027 traySide3, medAl);
8028
8029 forwTraySide3->SetVisibility(kTRUE);
8030 forwTraySide3->SetLineColor(6); // Purple
8031 forwTraySide3->SetLineWidth(1);
8032 forwTraySide3->SetFillColor(forwTraySide3->GetLineColor());
8033 forwTraySide3->SetFillStyle(4000); // 0% transparent
8034
8035 TGeoVolume *forwTrayHWing = new TGeoVolume("ITSsuppSDDSideAForwTrayHorWing",
8036 trayHorWing, medAl);
8037
8038 forwTrayHWing->SetVisibility(kTRUE);
8039 forwTrayHWing->SetLineColor(6); // Purple
8040 forwTrayHWing->SetLineWidth(1);
8041 forwTrayHWing->SetFillColor(forwTrayHWing->GetLineColor());
8042 forwTrayHWing->SetFillStyle(4000); // 0% transparent
8043
8044 TGeoVolume *forwTrayVWing = new TGeoVolume("ITSsuppSDDSideAForwTrayVertWing",
8045 trayVertWing, medAl);
8046
8047 forwTrayVWing->SetVisibility(kTRUE);
8048 forwTrayVWing->SetLineColor(6); // Purple
8049 forwTrayVWing->SetLineWidth(1);
8050 forwTrayVWing->SetFillColor(forwTrayVWing->GetLineColor());
8051 forwTrayVWing->SetFillStyle(4000); // 0% transparent
8052
8053
8054 // Now build up the tray
8055 yloc = kForwardTrayThick/2;
8056 zloc = zlen;
57126ea1 8057 tray->AddNode(forwTrayBase, 1,
8058 new TGeoTranslation(0, yloc, zloc) );
798b4e0c 8059
8060 xloc = kForwardTrayBaseHalfWide;
57126ea1 8061 tray->AddNode(forwTraySide1, 1,
8062 new TGeoCombiTrans(xloc, 0, 0,
798b4e0c 8063 new TGeoRotation("",90,-90,-90)));
8064 xloc = -xloc + kForwardTrayThick;
57126ea1 8065 tray->AddNode(forwTraySide1, 2,
8066 new TGeoCombiTrans(xloc, 0, 0,
798b4e0c 8067 new TGeoRotation("",90,-90,-90)));
8068
57126ea1 8069 tray->AddNode(forwTraySide2, 1, 0);
798b4e0c 8070 zloc = kForwardTraySideLength;
57126ea1 8071 tray->AddNode(forwTraySide2, 2,
8072 new TGeoCombiTrans(0, 0, zloc,
798b4e0c 8073 new TGeoRotation("",90,-180,-90)));
8074
8075 xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand;
57126ea1 8076 tray->AddNode(forwTraySide3, 1,
8077 new TGeoCombiTrans(xloc, 0, 0,
798b4e0c 8078 new TGeoRotation("",90,-90,-90)));
8079 xloc = -xloc + kForwardTrayThick;
57126ea1 8080 tray->AddNode(forwTraySide3, 2,
8081 new TGeoCombiTrans(xloc, 0, 0,
798b4e0c 8082 new TGeoRotation("",90,-90,-90)));
8083
8084 xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
8085 - kForwardTrayHorWingWide/2;
8086 yloc = traySide3->GetY(2) + kForwardTrayThick/2;
8087 zloc = kForwardTraySideLength - trayHorWing->GetDZ();
57126ea1 8088 tray->AddNode(forwTrayHWing, 1,
8089 new TGeoTranslation( xloc, yloc, zloc) );
8090 tray->AddNode(forwTrayHWing, 2,
8091 new TGeoTranslation(-xloc, yloc, zloc) );
798b4e0c 8092
8093 xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
8094 - kForwardTrayVertWingWide/2;
8095 yloc = traySide3->GetY(2) + trayVertWing->GetDY();
8096 zloc = traySide3->GetX(3) + kForwardTrayThick/2;
57126ea1 8097 tray->AddNode(forwTrayVWing, 1,
8098 new TGeoTranslation( xloc, yloc, zloc) );
8099 tray->AddNode(forwTrayVWing, 2,
8100 new TGeoTranslation(-xloc, yloc, zloc) );
798b4e0c 8101
8102
57126ea1 8103 return;
798b4e0c 8104}
8105
8106//______________________________________________________________________
8107TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAForwardCover(const Double_t coverLen){
8108//
8109// Creates the forward cover of the SDD and SSD cable trays on Side A
8110// (0872/G/D/02)
8111//
8112// Input:
8113// coverLen: the total length of the cover
8114//
8115// Output:
8116//
8117// Return: a TGeoCompositeShape for the cover
8118//
8119// Created: 03 Jan 2010 Mario Sitta
8120//
8121// Technical data are taken from AutoCAD drawings, L.Simonetti technical
8122// drawings and other (oral) information given by F.Tosello
8123//
8124
8125 // Dimensions and positions of the A-Side Cable Tray Forward Cover
8126 // (0872/G/D/02)
8127 const Double_t kForwardCoverWide = 130.00 *fgkmm;
8128 const Double_t kForwardCoverSideWide = 10.00 *fgkmm;
8129 const Double_t kForwardCoverHoleLen = 160.00 *fgkmm;
8130 const Double_t kForwardCoverHoleWide = 90.00 *fgkmm;
8131 const Double_t kForwardCoverHoleR10 = 10.00 *fgkmm;
8132 const Double_t kForwardCoverTotalThick = 5.00 *fgkmm;
8133 const Double_t kForwardCoverSideThick = 3.00 *fgkmm;
8134 const Double_t kForwardCoverInternThick = 2.00 *fgkmm;
8135
8136 const Double_t kForwardCoverHoleZTrans = 40.00 *fgkmm;
8137
8138
8139 // Local variables
8140 Double_t xprof[16], yprof[16];
8141 Double_t yloc, zloc;
8142
8143
8144 // The main shape: a Xtru
8145 TGeoXtru *forwCoverMain = new TGeoXtru(2);
8146 forwCoverMain->SetName("ITSsuppForwCoverMain");
8147
8148 xprof[0] = kForwardCoverWide/2;
8149 yprof[0] = kForwardCoverTotalThick;
8150 xprof[1] = xprof[0];
8151 yprof[1] = yprof[0] - kForwardCoverSideThick;
8152 xprof[2] = xprof[1] - kForwardCoverSideWide;
8153 yprof[2] = yprof[1];
8154 xprof[3] = xprof[2];
8155 yprof[3] = 0;
8156
8157 // We did the right side, now reflex on the left side
8158 for (Int_t jp = 0; jp < 4; jp++) {
8159 xprof[4+jp] = -xprof[3-jp];
8160 yprof[4+jp] = yprof[3-jp];
8161 }
8162
8163 // And now the actual Xtru
8164 forwCoverMain->DefinePolygon(8, xprof, yprof);
8165 forwCoverMain->DefineSection(0, 0);
8166 forwCoverMain->DefineSection(1, coverLen);
8167
8168 // The hole: another Xtru (rounded corners approximated with segments)
8169 TGeoXtru *forwCoverHole = new TGeoXtru(2);
8170 forwCoverHole->SetName("ITSsuppForwCoverHole");
8171
8172 CreateTrayACoverHolesShape(kForwardCoverHoleWide, kForwardCoverHoleLen,
8173 kForwardCoverHoleR10 , xprof, yprof);
8174
8175 // And now the actual Xtru
8176 forwCoverHole->DefinePolygon(16, xprof, yprof);
8177 forwCoverHole->DefineSection(0, 0);
8178 forwCoverHole->DefineSection(1, kForwardCoverTotalThick-kForwardCoverInternThick);
8179
8180 // Now the proper rototranslation matrices for the two holes
8181 yloc = kForwardCoverTotalThick-kForwardCoverInternThick-0.01;//Precision fix
8182 zloc = kForwardCoverHoleZTrans;
8183 TGeoCombiTrans *mf1 = new TGeoCombiTrans(0, yloc, zloc,
8184 new TGeoRotation("", 0, 90, 0) );
8185 mf1->SetName("mf1");
8186 mf1->RegisterYourself();
8187
8188 zloc = coverLen - kForwardCoverHoleZTrans - kForwardCoverHoleLen;
8189 TGeoCombiTrans *mf2 = new TGeoCombiTrans(0, yloc, zloc,
8190 new TGeoRotation("", 0, 90, 0) );
8191 mf2->SetName("mf2");
8192 mf2->RegisterYourself();
8193
8194 // Finally the actual cover shape
8195 TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppForwardCoverMain",
8196 "ITSsuppForwCoverMain-ITSsuppForwCoverHole:mf1-ITSsuppForwCoverHole:mf2");
8197
8198 return cover;
172b0d90 8199}
798b4e0c 8200
8201//______________________________________________________________________
8202TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAExternalCover(const Double_t coverLen){
8203//
8204// Creates the external cover of the SDD and SSD cable trays on Side A
8205// (0872/G/D/04)
8206//
8207// Input:
8208// coverLen: the total length of the cover
8209//
8210// Output:
8211//
8212// Return: a TGeoCompositeShape for the cover
8213//
8214// Created: 03 Jan 2010 Mario Sitta
8215//
8216// Technical data are taken from AutoCAD drawings, L.Simonetti technical
8217// drawings and other (oral) information given by F.Tosello
8218//
8219
8220 // Dimensions and positions of the A-Side Cable Tray External Cover
8221 // (0872/G/D/04)
8222 const Double_t kExternalCoverWide = 130.00 *fgkmm;
8223 const Double_t kExternalCoverSideWide = 10.00 *fgkmm;
8224 const Double_t kExternalCoverHoleLen1 = 262.00 *fgkmm;
8225 const Double_t kExternalCoverHoleLen2 = 280.00 *fgkmm;
8226 const Double_t kExternalCoverHoleLen3 = 205.00 *fgkmm;
8227 const Double_t kExternalCoverHoleLen4 = 55.00 *fgkmm;
8228 const Double_t kExternalCoverHoleWide = 90.00 *fgkmm;
8229 const Double_t kExternalCoverHoleR10 = 10.00 *fgkmm;
8230 const Double_t kExternalCoverTotalThick = 5.00 *fgkmm;
8231 const Double_t kExternalCoverSideThick = 3.00 *fgkmm;
8232 const Double_t kExternalCoverInternThick = 2.00 *fgkmm;
8233
8234 const Double_t kExternalCoverHole1ZTrans = 28.00 *fgkmm;
8235 const Double_t kExternalCoverHolesZTrans = 20.00 *fgkmm;
8236
8237
8238 // Local variables
8239 Double_t xprof[16], yprof[16];
8240 Double_t yloc, zloc;
8241
8242
8243 // The main shape: a Xtru
8244 TGeoXtru *externCoverMain = new TGeoXtru(2);
8245 externCoverMain->SetName("ITSsuppExternCoverMain");
8246
8247 xprof[0] = kExternalCoverWide/2;
8248 yprof[0] = kExternalCoverTotalThick;
8249 xprof[1] = xprof[0];
8250 yprof[1] = yprof[0] - kExternalCoverSideThick;
8251 xprof[2] = xprof[1] - kExternalCoverSideWide;
8252 yprof[2] = yprof[1];
8253 xprof[3] = xprof[2];
8254 yprof[3] = 0;
8255
8256 // We did the right side, now reflex on the left side
8257 for (Int_t jp = 0; jp < 4; jp++) {
8258 xprof[4+jp] = -xprof[3-jp];
8259 yprof[4+jp] = yprof[3-jp];
8260 }
8261
8262 // And now the actual Xtru
8263 externCoverMain->DefinePolygon(8, xprof, yprof);
8264 externCoverMain->DefineSection(0, 0);
8265 externCoverMain->DefineSection(1, coverLen);
8266
8267 // The first hole: a Xtru (rounded corners approximated with segments)
8268 Double_t holethick = kExternalCoverTotalThick-kExternalCoverInternThick;
8269
8270 TGeoXtru *extCoverHole1 = new TGeoXtru(2);
8271 extCoverHole1->SetName("ITSsuppExtCoverHole1");
8272
8273 CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen1,
8274 kExternalCoverHoleR10 , xprof, yprof);
8275
8276 extCoverHole1->DefinePolygon(16, xprof, yprof);
8277 extCoverHole1->DefineSection(0, 0);
8278 extCoverHole1->DefineSection(1, holethick);
8279
8280 // The second (and third) hole: another Xtru
8281 TGeoXtru *extCoverHole2 = new TGeoXtru(2);
8282 extCoverHole2->SetName("ITSsuppExtCoverHole2");
8283
8284 CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen2,
8285 kExternalCoverHoleR10 , xprof, yprof);
8286
8287 extCoverHole2->DefinePolygon(16, xprof, yprof);
8288 extCoverHole2->DefineSection(0, 0);
8289 extCoverHole2->DefineSection(1, holethick);
8290
8291 // The fourth hole: another Xtru
8292 TGeoXtru *extCoverHole3 = new TGeoXtru(2);
8293 extCoverHole3->SetName("ITSsuppExtCoverHole3");
8294
8295 CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen3,
8296 kExternalCoverHoleR10 , xprof, yprof);
8297
8298 extCoverHole3->DefinePolygon(16, xprof, yprof);
8299 extCoverHole3->DefineSection(0, 0);
8300 extCoverHole3->DefineSection(1, holethick);
8301
8302 // The fifth and last hole: another Xtru
8303 TGeoXtru *extCoverHole4 = new TGeoXtru(2);
8304 extCoverHole4->SetName("ITSsuppExtCoverHole4");
8305
8306 CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen4,
8307 kExternalCoverHoleR10 , xprof, yprof);
8308
8309 extCoverHole4->DefinePolygon(16, xprof, yprof);
8310 extCoverHole4->DefineSection(0, 0);
8311 extCoverHole4->DefineSection(1, holethick);
8312
8313 // Now the proper rototranslation matrices for the holes
8314 yloc = kExternalCoverTotalThick - kExternalCoverInternThick-0.01;
8315 zloc = kExternalCoverHole1ZTrans;
8316 TGeoCombiTrans *me1 = new TGeoCombiTrans(0, yloc, zloc,
8317 new TGeoRotation("", 0, 90, 0) );
8318 me1->SetName("me1");
8319 me1->RegisterYourself();
8320
8321 zloc += (kExternalCoverHoleLen1 + kExternalCoverHolesZTrans);
8322 TGeoCombiTrans *me2 = new TGeoCombiTrans(0, yloc, zloc,
8323 new TGeoRotation("", 0, 90, 0) );
8324 me2->SetName("me2");
8325 me2->RegisterYourself();
8326
8327 zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
8328 TGeoCombiTrans *me3 = new TGeoCombiTrans(0, yloc, zloc,
8329 new TGeoRotation("", 0, 90, 0) );
8330 me3->SetName("me3");
8331 me3->RegisterYourself();
8332
8333 zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
8334 TGeoCombiTrans *me4 = new TGeoCombiTrans(0, yloc, zloc,
8335 new TGeoRotation("", 0, 90, 0) );
8336 me4->SetName("me4");
8337 me4->RegisterYourself();
8338
8339 zloc += (kExternalCoverHoleLen3 + kExternalCoverHolesZTrans);
8340 TGeoCombiTrans *me5 = new TGeoCombiTrans(0, yloc, zloc,
8341 new TGeoRotation("", 0, 90, 0) );
8342 me5->SetName("me5");
8343 me5->RegisterYourself();
8344
8345 // Finally the actual cover shape
8346 TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppExternCoverMain",
8347 "ITSsuppExternCoverMain-ITSsuppExtCoverHole1:me1-ITSsuppExtCoverHole2:me2-ITSsuppExtCoverHole2:me3-ITSsuppExtCoverHole3:me4-ITSsuppExtCoverHole4:me5");
8348
8349 return cover;
8350}
8351
8352//______________________________________________________________________
8353void AliITSv11GeometrySupport::CreateTrayACoverHolesShape(const Double_t wide,
8354 const Double_t length, const Double_t r10,
8355 Double_t *x, Double_t *y){
8356//
8357// Creates the proper sequence of X and Y coordinates to determine
8358// the base XTru polygon for the holes in the SDD and SSD tray covers
8359// (here the rounded corners are approximated with segments)
8360//
8361// Input:
8362// wide : the hole wide
8363// length : the hole length
8364// r10 : the radius of the rounded corners
8365//
8366// Output:
8367// x, y : coordinate vectors [16]
8368//
8369// Created: 03 Jan 2010 Mario Sitta
8370//
8371// Caller must guarantee that x and y have the correct dimensions
8372// (but being this a private method it's easy to tell)
8373//
8374
8375 x[0] = wide/2 - r10;
8376 y[0] = length;
8377 x[1] = x[0] + r10*SinD(30);
8378 y[1] = y[0] - r10*(1 - CosD(30));
8379 x[2] = x[0] + r10*SinD(60);
8380 y[2] = y[0] - r10*(1 - CosD(60));
8381 x[3] = x[0] + r10;
8382 y[3] = y[0] - r10;
8383 x[4] = x[3];
8384 y[4] = r10;
8385 x[5] = x[4] - r10*(1 - CosD(30));
8386 y[5] = y[4] - r10*SinD(30);
8387 x[6] = x[4] - r10*(1 - CosD(60));
8388 y[6] = y[4] - r10*SinD(60);
8389 x[7] = x[4] - r10;
8390 y[7] = 0;
8391
8392 // We did the right side, now reflex on the left side
8393 for (Int_t jp = 0; jp < 8; jp++) {
8394 x[8+jp] = -x[7-jp];
8395 y[8+jp] = y[7-jp];
8396 }
8397
8398 return;
8399}
8400
8401//______________________________________________________________________
8402TGeoXtru* AliITSv11GeometrySupport::CreateSDDSSDTraysSideA(
8403 const Double_t trayLen,
8404 const Double_t trayHi){
8405//
8406// Creates parts of the SDD and SSD Trays on Side A which are identical
8407// (0872/G/D/03, part of 0872/G/D/07, 0872/G/C/11)
8408//
8409// Input:
8410// trayLen : the length of the tray part
8411// trayHi : the height of the tray part
8412//
8413// Output:
8414//
8415// Return: a TGeoXtru
8416//
8417// Created: 26 Feb 2010 Mario Sitta
8418//
8419// Technical data are taken from AutoCAD drawings, L.Simonetti technical
8420// drawings and other (oral) information given by F.Tosello
8421//
8422
8423 // Dimensions and positions of the A-Side Cable Trays
8424 // (parts of 0872/G/C)
8425 const Double_t kTrayWidth = 130.00 *fgkmm;
8426 const Double_t kTrayWingWidth = 10.00 *fgkmm;
8427 const Double_t kTrayHeightToBend = 20.00 *fgkmm;
8428 const Double_t kTrayThick = 2.00 *fgkmm;
8429
8430 const Double_t kTrayBendAngle = 22.00 *TMath::DegToRad();
8431
8432 const Int_t kTrayNpoints = 16;
8433
8434 // Local variables
8435 Double_t xprof[kTrayNpoints], yprof[kTrayNpoints];
8436
8437
8438 // The tray shape: a Xtru
8439 TGeoXtru *trayPart = new TGeoXtru(2);
8440
8441 xprof[2] = kTrayWidth/2 - kTrayThick;
8442 yprof[2] = trayHi - kTrayThick;
8443 xprof[3] = kTrayWidth/2 - kTrayWingWidth;
8444 yprof[3] = yprof[2];
8445 xprof[4] = xprof[3];
8446 yprof[4] = trayHi;
8447 xprof[5] = kTrayWidth/2;
8448 yprof[5] = yprof[4];
8449 xprof[6] = xprof[5];
8450 yprof[6] = kTrayHeightToBend;
8451 xprof[7] = xprof[6] - yprof[6]*TMath::Tan(kTrayBendAngle);
8452 yprof[7] = 0;
8453
8454 InsidePoint( xprof[5], yprof[5], xprof[6], yprof[6], xprof[7], yprof[7],
8455 -kTrayThick, xprof[1], yprof[1]);
8456
8457 xprof[8] = -xprof[7];
8458 yprof[8] = yprof[7];
8459
8460 InsidePoint( xprof[6], yprof[6], xprof[7], yprof[7], xprof[8], yprof[8],
8461 -kTrayThick, xprof[0], yprof[0]);
8462
8463 // We did the right side, now reflex on the left side
8464 for (Int_t jp = 0; jp < 8; jp++) {
8465 xprof[8+jp] = -xprof[7-jp];
8466 yprof[8+jp] = yprof[7-jp];
8467 }
8468
8469 // And now the actual Xtru
8470 trayPart->DefinePolygon(kTrayNpoints, xprof, yprof);
8471 trayPart->DefineSection(0, 0);
8472 trayPart->DefineSection(1, trayLen);
8473
8474
8475 return trayPart;
8476}
8477
aa177c73 8478//______________________________________________________________________
8479TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDSSDTraysSideC(
43aefea7 8480 const char *trayName,
8481 const TGeoManager *mgr){
aa177c73 8482
8483//
8484// Creates the SDD and SSD Trays on Side C which are supposedly identical
8485//
8486// Input:
8487// trayName : the assembly name
8488//
8489// Output:
8490//
8491// Return: a TGeoVolumeAssembly
8492//
8493// Created: 16 Apr 2010 Mario Sitta
8494//
8495// Technical data are taken from AutoCAD drawings and other (oral)
8496// information given by F.Tosello
8497//
8498
8499 const Double_t kSideCHalfThick = 0.100 *fgkcm;
8500 const Double_t kSideCFoldAngle = 5.000 *TMath::DegToRad();
8501
8502 const Double_t kSideCLength1 = 172.800 *fgkcm;
8503 const Double_t kSideCLength2 = 189.300 *fgkcm;
8504 const Double_t kSideCHalfWide = 6.350 *fgkcm;
8505 const Double_t kSideCHeight1 = 11.800 *fgkcm;
8506 const Double_t kSideCHeight2 = 4.300 *fgkcm;
8507 const Double_t kSideCSideLength1 = 10.800 *fgkcm;
8508 const Double_t kSideCSideLength2 = 63.800 *fgkcm;
8509 const Double_t kSideCSideHeight = 8.800 *fgkcm;
8510 const Int_t kNPointsLowerFace = 6;
8511 const Int_t kNPointsLateralFace = 9;
8512
8513 const Double_t kSideCWingAHalfLen = 5.000 *fgkcm;
8514 const Double_t kSideCWingBHalfLen = 30.500 *fgkcm;
8515 const Double_t kSideCWingCHalfLen = 2.000 *fgkcm;
8516 const Double_t kSideCWingDHalfLen = 48.500 *fgkcm;
8517 const Double_t kSideCWingEHalfLen = 83.000 *fgkcm;
8518 const Double_t kSideCWingsHalfWide = 0.450 *fgkcm;
8519
8520 const Int_t kNPointsCoverFace = 12;
8521
8522 const Double_t kPlateHalfLen = 6.000 *fgkcm;
8523 const Double_t kPlateThick = 0.600 *fgkcm;
8524 const Double_t kPlateHeight = 4.200 *fgkcm;
8525 const Int_t kNPointsPlate = 6;
8526
8527 const Double_t kBarCoolRmax = 0.4 *fgkcm;
8528 const Int_t kNumBarCool = 2;
8529 const Double_t kXShiftBarCool[kNumBarCool] = { 8.7, 13.0 };
8530 const Double_t kYShiftBarCool[kNumBarCool] = { 8.5, 5.0 };
8531
8532
8533 // Local variables
8534 Double_t xprof[12], yprof[12];
8535 Double_t xloc, yloc, zloc, delta, alpharot;
8536
8537 // The single C-Side Cable tray as an assembly
8538 TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly(trayName);
8539
8540 // First create all needed shapes
8541
8542 // The Cable Tray lower face: a Xtru
8543 TGeoXtru *sideCLowerFace = new TGeoXtru(2);
8544
8545 xprof[0] = 0.;
8546 yprof[0] = 0.;
8547 xprof[1] = kSideCLength1;
8548 yprof[1] = 0.;
8549 xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle);
8550 yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle);
8551 xprof[3] = xprof[2] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle);
8552 yprof[3] = yprof[2] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle);
8553 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
8554 2*kSideCHalfThick , xprof[4], yprof[4]);
8555 xprof[5] = 0.;
8556 yprof[5] = 2*kSideCHalfThick;
8557
8558 sideCLowerFace->DefinePolygon(kNPointsLowerFace, xprof, yprof);
8559 sideCLowerFace->DefineSection(0,-kSideCHalfWide);
8560 sideCLowerFace->DefineSection(1, kSideCHalfWide);
8561
8562 // The Cable Tray lateral face: a Xtru
8563 TGeoXtru *sideCLateralFace = new TGeoXtru(2);
8564
8565 xprof[0] = 0.;
8566 yprof[0] = 0.;
8567 xprof[1] = kSideCLength1;
8568 yprof[1] = 0.;
8569 xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle);
8570 yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle);
8571 xprof[3] = xprof[2] - kSideCHeight2*TMath::Sin(kSideCFoldAngle);
8572 yprof[3] = yprof[2] + kSideCHeight2*TMath::Cos(kSideCFoldAngle);
8573 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
8574 kSideCHeight2, xprof[4], yprof[4]);
8575 xprof[5] = kSideCSideLength1 + kSideCSideLength2;
8576 yprof[5] = kSideCHeight2;
8577 xprof[6] = xprof[5];
8578 yprof[6] = kSideCSideHeight;
8579 xprof[7] = kSideCSideLength1;
8580 yprof[7] = kSideCHeight1;
8581 xprof[8] = 0;
8582 yprof[8] = yprof[7];
8583
8584 sideCLateralFace->DefinePolygon(kNPointsLateralFace, xprof, yprof);
8585 sideCLateralFace->DefineSection(0,-kSideCHalfThick);
8586 sideCLateralFace->DefineSection(1, kSideCHalfThick);
8587
8588 // The lateral wings: four BBox's
8589 TGeoBBox *sideCLateralWingA = new TGeoBBox(kSideCWingAHalfLen,
8590 kSideCHalfThick,
8591 kSideCWingsHalfWide);
8592
8593 TGeoBBox *sideCLateralWingB = new TGeoBBox(kSideCWingBHalfLen,
8594 kSideCHalfThick,
8595 kSideCWingsHalfWide);
8596
8597 TGeoBBox *sideCLateralWingC = new TGeoBBox(kSideCHalfThick, // With these
8598 kSideCWingCHalfLen, // X,Y avoid
8599 kSideCWingsHalfWide);//rotations
8600
8601 TGeoBBox *sideCLateralWingD = new TGeoBBox(kSideCWingDHalfLen,
8602 kSideCHalfThick,
8603 kSideCWingsHalfWide);
8604
8605 TGeoBBox *sideCLateralWingE = new TGeoBBox(kSideCWingEHalfLen,
8606 kSideCHalfThick,
8607 kSideCWingsHalfWide);
8608
8609 // The connecting lower plate: a Xtru
8610 TGeoXtru *sideCLowerPlate = new TGeoXtru(2);
8611
8612 xprof[0] = 0.;
8613 yprof[0] = 0.;
8614 xprof[1] = kPlateHalfLen;
8615 yprof[1] = 0.;
8616 xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle);
8617 yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle);
8618 xprof[3] = xprof[2] - kPlateThick*TMath::Sin(kSideCFoldAngle);
8619 yprof[3] = yprof[2] + kPlateThick*TMath::Cos(kSideCFoldAngle);
8620 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
8621 kPlateThick, xprof[4], yprof[4]);
8622 xprof[5] = 0.;
8623 yprof[5] = kPlateThick;
8624
8625 sideCLowerPlate->DefinePolygon(kNPointsPlate, xprof, yprof);
8626 Double_t zwide = kSideCHalfWide + 2*kSideCHalfThick;
8627 sideCLowerPlate->DefineSection(0,-zwide);
8628 sideCLowerPlate->DefineSection(1, zwide);
8629
8630 // The connecting side plate: a Xtru
8631 TGeoXtru *sideCLateralPlate = new TGeoXtru(2);
8632
8633 xprof[0] = 0.;
8634 yprof[0] = 0.;
8635 xprof[1] = kPlateHalfLen;
8636 yprof[1] = 0.;
8637 xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle);
8638 yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle);
8639 xprof[3] = xprof[2] - kPlateHeight*TMath::Sin(kSideCFoldAngle);
8640 yprof[3] = yprof[2] + kPlateHeight*TMath::Cos(kSideCFoldAngle);
8641 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
8642 kPlateHeight, xprof[4], yprof[4]); // Avoid small overlap
8643 xprof[5] = 0.;
8644 yprof[5] = kPlateHeight;
8645
8646 sideCLateralPlate->DefinePolygon(kNPointsPlate, xprof, yprof);
8647 sideCLateralPlate->DefineSection(0,-kPlateThick/2);
8648 sideCLateralPlate->DefineSection(1, kPlateThick/2);
8649
8650 // The bar fixing the cooling tubes: a Tube
8651 TGeoTube *coolBar = new TGeoTube(0., kBarCoolRmax, kSideCHalfWide);
8652
8653 // The Cable Tray cover: a (complex) Xtru
8654 TGeoXtru *sideCCoverFace = new TGeoXtru(2);
8655
8656 xprof[ 0] = sideCLateralFace->GetX(8);
8657 yprof[ 0] = sideCLateralFace->GetY(8);
8658 xprof[ 1] = sideCLateralFace->GetX(7);
8659 yprof[ 1] = sideCLateralFace->GetY(7);
8660 xprof[ 2] = sideCLateralFace->GetX(6);
8661 yprof[ 2] = sideCLateralFace->GetY(6);
8662 xprof[ 3] = sideCLateralFace->GetX(5);
8663 yprof[ 3] = sideCLateralFace->GetY(5);
8664 xprof[ 4] = sideCLateralFace->GetX(4);
8665 yprof[ 4] = sideCLateralFace->GetY(4);
8666
8667 xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2;
8668 delta = kSideCLength1 - (xloc + kSideCWingDHalfLen);
8669 xprof[ 5] = xprof[4]
8670 + (delta + 2*kSideCWingEHalfLen)*TMath::Cos(kSideCFoldAngle);
8671 yprof[ 5] = yprof[4]
8672 + (delta + 2*kSideCWingEHalfLen)*TMath::Sin(kSideCFoldAngle);
8673
8674 xprof[ 6] = xprof[5] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle);
8675 yprof[ 6] = yprof[5] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle);
8676 InsidePoint(xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
8677 2*kSideCHalfThick, xprof[7], yprof[7]);
8678 InsidePoint(xprof[2], yprof[2], xprof[3], yprof[3], xprof[4], yprof[4],
8679 2*kSideCHalfThick, xprof[8], yprof[8]);
8680 xprof[ 9] = xprof[2] + 2*kSideCHalfThick;
8681 yprof[ 9] = yprof[2] + 2*kSideCHalfThick;
8682 xprof[10] = xprof[1];
8683 yprof[10] = yprof[1] + 2*kSideCHalfThick;
8684 xprof[11] = xprof[0];
8685 yprof[11] = yprof[0] + 2*kSideCHalfThick;
8686
8687 sideCCoverFace->DefinePolygon(kNPointsCoverFace, xprof, yprof);
8688 zloc = kSideCHalfWide + 2*kSideCHalfThick + 2*kSideCWingsHalfWide;
8689 sideCCoverFace->DefineSection(0,-zloc);
8690 sideCCoverFace->DefineSection(1, zloc);
8691
8692
8693 // We have all shapes: now create the real volumes
0801d201 8694 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
aa177c73 8695
8696 TGeoVolume *traySideCLowerFace = new TGeoVolume("ITSsuppTraySideCLower",
8697 sideCLowerFace, medAl);
8698
8699 traySideCLowerFace->SetVisibility(kTRUE);
8700 traySideCLowerFace->SetLineColor(6); // Purple
8701 traySideCLowerFace->SetLineWidth(1);
8702 traySideCLowerFace->SetFillColor(traySideCLowerFace->GetLineColor());
8703 traySideCLowerFace->SetFillStyle(4000); // 0% transparent
8704
8705 TGeoVolume *traySideCLateralFace = new TGeoVolume("ITSsuppTraySideCLateral",
8706 sideCLateralFace, medAl);
8707
8708 traySideCLateralFace->SetVisibility(kTRUE);
8709 traySideCLateralFace->SetLineColor(6); // Purple
8710 traySideCLateralFace->SetLineWidth(1);
8711 traySideCLateralFace->SetFillColor(traySideCLateralFace->GetLineColor());
8712 traySideCLateralFace->SetFillStyle(4000); // 0% transparent
8713
8714 TGeoVolume *traySideCLateralWingA =
8715 new TGeoVolume("ITSsuppTraySideCLateralWingA", sideCLateralWingA, medAl);
8716
8717 traySideCLateralWingA->SetVisibility(kTRUE);
8718 traySideCLateralWingA->SetLineColor(6); // Purple
8719 traySideCLateralWingA->SetLineWidth(1);
8720 traySideCLateralWingA->SetFillColor(traySideCLateralWingA->GetLineColor());
8721 traySideCLateralWingA->SetFillStyle(4000); // 0% transparent
8722
8723 TGeoVolume *traySideCLateralWingB =
8724 new TGeoVolume("ITSsuppTraySideCLateralWingB", sideCLateralWingB, medAl);
8725
8726 traySideCLateralWingB->SetVisibility(kTRUE);
8727 traySideCLateralWingB->SetLineColor(6); // Purple
8728 traySideCLateralWingB->SetLineWidth(1);
8729 traySideCLateralWingB->SetFillColor(traySideCLateralWingB->GetLineColor());
8730 traySideCLateralWingB->SetFillStyle(4000); // 0% transparent
8731
8732 TGeoVolume *traySideCLateralWingC =
8733 new TGeoVolume("ITSsuppTraySideCLateralWingC", sideCLateralWingC, medAl);
8734
8735 traySideCLateralWingC->SetVisibility(kTRUE);
8736 traySideCLateralWingC->SetLineColor(6); // Purple
8737 traySideCLateralWingC->SetLineWidth(1);
8738 traySideCLateralWingC->SetFillColor(traySideCLateralWingC->GetLineColor());
8739 traySideCLateralWingC->SetFillStyle(4000); // 0% transparent
8740
8741 TGeoVolume *traySideCLateralWingD =
8742 new TGeoVolume("ITSsuppTraySideCLateralWingD", sideCLateralWingD, medAl);
8743
8744 traySideCLateralWingD->SetVisibility(kTRUE);
8745 traySideCLateralWingD->SetLineColor(6); // Purple
8746 traySideCLateralWingD->SetLineWidth(1);
8747 traySideCLateralWingD->SetFillColor(traySideCLateralWingD->GetLineColor());
8748 traySideCLateralWingD->SetFillStyle(4000); // 0% transparent
8749
8750 TGeoVolume *traySideCLateralWingE =
8751 new TGeoVolume("ITSsuppTraySideCLateralWingE", sideCLateralWingE, medAl);
8752
8753 traySideCLateralWingE->SetVisibility(kTRUE);
8754 traySideCLateralWingE->SetLineColor(6); // Purple
8755 traySideCLateralWingE->SetLineWidth(1);
8756 traySideCLateralWingE->SetFillColor(traySideCLateralWingE->GetLineColor());
8757 traySideCLateralWingE->SetFillStyle(4000); // 0% transparent
8758
8759 TGeoVolume *traySideCLowerPlate =
8760 new TGeoVolume("ITSsuppTraySideCLowerPlate", sideCLowerPlate, medAl);
8761
8762 traySideCLowerPlate->SetVisibility(kTRUE);
8763 traySideCLowerPlate->SetLineColor(6); // Purple
8764 traySideCLowerPlate->SetLineWidth(1);
8765 traySideCLowerPlate->SetFillColor(traySideCLowerPlate->GetLineColor());
8766 traySideCLowerPlate->SetFillStyle(4000); // 0% transparent
8767
8768 TGeoVolume *traySideCLateralPlate =
8769 new TGeoVolume("ITSsuppTraySideCLateralPlate", sideCLateralPlate, medAl);
8770
8771 traySideCLateralPlate->SetVisibility(kTRUE);
8772 traySideCLateralPlate->SetLineColor(6); // Purple
8773 traySideCLateralPlate->SetLineWidth(1);
8774 traySideCLateralPlate->SetFillColor(traySideCLateralPlate->GetLineColor());
8775 traySideCLateralPlate->SetFillStyle(4000); // 0% transparent
8776
8777 TGeoVolume *traySideCCoverFace =
8778 new TGeoVolume("ITSsuppTraySideCCoverFace", sideCCoverFace, medAl);
8779
8780 traySideCCoverFace->SetVisibility(kTRUE);
8781 traySideCCoverFace->SetLineColor(6); // Purple
8782 traySideCCoverFace->SetLineWidth(1);
8783 traySideCCoverFace->SetFillColor(traySideCCoverFace->GetLineColor());
8784 traySideCCoverFace->SetFillStyle(4000); // 0% transparent
8785
8786 TGeoVolume *coolingTubeBar = new TGeoVolume("ITSsuppTraySideCCoolBar",
8787 coolBar, medAl);
8788
8789 coolingTubeBar->SetVisibility(kTRUE);
8790 coolingTubeBar->SetLineColor(6); // Purple
8791 coolingTubeBar->SetLineWidth(1);
8792 coolingTubeBar->SetFillColor(coolingTubeBar->GetLineColor());
8793 coolingTubeBar->SetFillStyle(4000); // 0% transparent
8794
8795
8796 // Now build up the tray
8797 cableTrayC->AddNode(traySideCLowerFace,1,0);
8798
8799 zloc = kSideCHalfWide + kSideCHalfThick;
8800 cableTrayC->AddNode(traySideCLateralFace,1,
8801 new TGeoTranslation(0., 0., zloc) );
8802 cableTrayC->AddNode(traySideCLateralFace,2,
8803 new TGeoTranslation(0., 0.,-zloc) );
8804
8805 xloc = kSideCWingAHalfLen;
8806 yloc = kSideCHeight1 - kSideCHalfThick;
8807 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8808 cableTrayC->AddNode(traySideCLateralWingA,1,
8809 new TGeoTranslation(xloc, yloc, zloc) );
8810 cableTrayC->AddNode(traySideCLateralWingA,2,
8811 new TGeoTranslation(xloc, yloc,-zloc) );
8812
8813 xloc = kSideCSideLength1 + kSideCSideLength2/2;
8814 yloc = Yfrom2Points(kSideCSideLength1,kSideCHeight1,
8815 kSideCSideLength1+kSideCSideLength2,kSideCSideHeight,
8816 xloc) - kSideCHalfThick -0.0012; // Avoid small overlap
8817 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8818 alpharot = (-(kSideCHeight1 - kSideCSideHeight)/kSideCSideLength2 )*
8819 TMath::RadToDeg();
8820 cableTrayC->AddNode(traySideCLateralWingB,1,
8821 new TGeoCombiTrans(xloc, yloc, zloc,
8822 new TGeoRotation("",alpharot,0,0) ) );
8823 cableTrayC->AddNode(traySideCLateralWingB,2,
8824 new TGeoCombiTrans(xloc, yloc,-zloc,
8825 new TGeoRotation("",alpharot,0,0) ) );
8826
8827 xloc = kSideCSideLength1 + kSideCSideLength2 - kSideCHalfThick;
8828 yloc = kSideCSideHeight - kSideCWingCHalfLen;
8829 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8830 cableTrayC->AddNode(traySideCLateralWingC,1,
8831 new TGeoTranslation(xloc, yloc, zloc) );
8832 cableTrayC->AddNode(traySideCLateralWingC,2,
8833 new TGeoTranslation(xloc, yloc,-zloc) );
8834
8835 xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2;
8836 yloc = kSideCHeight2 - kSideCHalfThick;
8837 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8838 cableTrayC->AddNode(traySideCLateralWingD,1,
8839 new TGeoTranslation(xloc, yloc, zloc) );
8840 cableTrayC->AddNode(traySideCLateralWingD,2,
8841 new TGeoTranslation(xloc, yloc,-zloc) );
8842
8843 delta = kSideCLength1 - (xloc + kSideCWingDHalfLen);
8844 xloc = kSideCLength1 + delta + kSideCWingEHalfLen;
8845 yloc = (xloc - kSideCLength1)*TMath::Tan(kSideCFoldAngle) +
8846 kSideCHeight2*TMath::Cos(kSideCFoldAngle) - kSideCHalfThick;
8847 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8848 alpharot = kSideCFoldAngle*TMath::RadToDeg();
8849 cableTrayC->AddNode(traySideCLateralWingE,1,
8850 new TGeoCombiTrans(xloc, yloc, zloc,
8851 new TGeoRotation("",alpharot,0,0) ) );
8852 cableTrayC->AddNode(traySideCLateralWingE,2,
8853 new TGeoCombiTrans(xloc, yloc,-zloc,
8854 new TGeoRotation("",alpharot,0,0) ) );
8855
8856 xloc = kSideCLength1 - kPlateHalfLen;
8857 yloc = -kPlateThick -0.0025; // Avoid small overlap
8858 cableTrayC->AddNode(traySideCLowerPlate,1,
8859 new TGeoTranslation(xloc, yloc, 0.) );
8860
8861 xloc = kSideCLength1 - kPlateHalfLen;
8862 yloc = -kPlateThick;
8863 zloc = kSideCHalfWide + 2*kSideCHalfThick + kPlateThick/2;
8864 cableTrayC->AddNode(traySideCLateralPlate,1,
8865 new TGeoTranslation(xloc, yloc, zloc) );
8866 cableTrayC->AddNode(traySideCLateralPlate,2,
8867 new TGeoTranslation(xloc, yloc,-zloc) );
8868
8869 for (Int_t jc = 0; jc <kNumBarCool; jc++) {
8870 xloc = kXShiftBarCool[jc];
8871 yloc = kYShiftBarCool[jc];
8872 cableTrayC->AddNode(coolingTubeBar,jc+1,
8873 new TGeoTranslation(xloc, yloc, 0.) );
8874 }
8875
8876 cableTrayC->AddNode(traySideCCoverFace,1,0);
8877
8878
8879 // Finally return what we made up
8880
8881 return cableTrayC;
8882}
8883
f0a991bf 8884//______________________________________________________________________
8885void AliITSv11GeometrySupport::ITSTPCSupports(TGeoVolume *moth,
43aefea7 8886 const TGeoManager *mgr){
f0a991bf 8887//
8888// Creates the elements suspending the ITS to the TPC and other fixed
8889// elements used to hook the rails (0872/C and its daughters)
8890//
8b0d638d 8891// Input:
f0a991bf 8892// moth : the TGeoVolume owing the volume structure
8893// mgr : the GeoManager (default gGeoManager)
8894// Output:
8895//
8896// Return:
8897//
8898// Created: 28 Oct 2010 Mario Sitta
8b0d638d 8899// Updated: 18 Feb 2011 Mario Sitta
f0a991bf 8900//
8901// Technical data are taken from AutoCAD drawings, L.Simonetti technical
8902// drawings and other (oral) information given by F.Tosello
8903//
8904
8905 // Dimensions and positions of the half ring C2/C3 (0872/C/04)
8906 const Double_t kRingCZPos = 733.000*fgkmm;
8b0d638d 8907 const Double_t kRingCZToTPC = 5.500*fgkmm;
f0a991bf 8908
8909 const Double_t kRingCThick = 12.000*fgkmm;
8910 const Double_t kRingCRmin = 565.000*fgkmm;
8911 const Double_t kRingCRmax = 592.000*fgkmm;
8912 const Double_t kRingCHeight = 560.000*fgkmm;
8913 const Double_t kRingCXToInsert = 515.000*fgkmm;
8914 const Double_t kRingCYToInsert = 113.000*fgkmm;
8915
8916 const Int_t kNumberOfRingPoints = 23; // N.points to approximate arc
8917
8918 // Dimensions of the forward upper hook (0872/C/09)
8919 const Double_t kForwUpHookThick = 20.000*fgkmm;
8920 const Double_t kForwUpHookRext = 590.000*fgkmm;
8921 const Double_t kForwUpHookRint = 20.000*fgkmm;
8922 const Double_t kForwUpHookHiTot = 89.000*fgkmm;
8923 const Double_t kForwUpHookHiInt = 59.000*fgkmm;
8924 const Double_t kForwUpHookWide = 96.000*fgkmm;
8925 const Double_t kForwUpHookHalfBase = 25.000*fgkmm;
8926 const Double_t kForwUpHookBaseCut = 10.000*fgkmm;
8927 const Double_t kForwUpHookHoleWide = 25.000*fgkmm;
8928 const Double_t kForwUpHookHoleHi = 22.500*fgkmm;
8929 const Double_t kForwUpHookHoleBase = 5.000*fgkmm;
8930 const Double_t kForwUpHookHoleR5 = 5.000*fgkmm;
8931 const Double_t kForwUpHookHoleY = 8.000*fgkmm;
8932 const Double_t kForwUpHookHollowHi = 35.000*fgkmm;
8933 const Double_t kForwUpHookHollowWide= 5.000*fgkmm;
8934
8935 const Int_t kNumberOfForwUpHookPts = 11;
8936 const Int_t kNumbOfForwUpHookHolePts= 5;
8937
8938 // Dimensions of the forward lower hook (0872/C/08)
8939 const Double_t kForwLwHookThick = 20.000*fgkmm;
8940 const Double_t kForwLwHookRext = 590.000*fgkmm;
8941 const Double_t kForwLwHookRint = 20.000*fgkmm;
8942 const Double_t kForwLwHookHiTot = 88.500*fgkmm;
8943 const Double_t kForwLwHookWide = 96.000*fgkmm;
8944 const Double_t kForwLwHookHalfBase = 25.000*fgkmm;
8945 const Double_t kForwLwHookBaseCut = 10.000*fgkmm;
8946 const Double_t kForwLwHookYToHollow = 3.500*fgkmm;
8947 const Double_t kForwLwHookHoleR = 7.500*fgkmm;
8948 const Double_t kForwLwHookHoleIntHi = 35.000*fgkmm;
8949 const Double_t kForwLwHookHoleYPos = 13.500*fgkmm;
8950 const Double_t kForwLwHookHollowHi = 62.000*fgkmm;
8951 const Double_t kForwLwHookHollowWide= 5.000*fgkmm;
8952
8953 const Int_t kNumberOfForwLwHookPts = 11;
8954 const Int_t kNumbOfForwLwHookHolePts= 7;
8955
8956 // Dimensions of the rear upper hook (0872/C/10)
8957 const Double_t kRearUpHookThick = 15.000*fgkmm;
8958 const Double_t kRearUpHookRext = 590.000*fgkmm;
8959 const Double_t kRearUpHookRint = 20.000*fgkmm;
8960 const Double_t kRearUpHookHiTot = 53.500*fgkmm;
8961 const Double_t kRearUpHookHiInt = 23.500*fgkmm;
8962 const Double_t kRearUpHookWide = 96.000*fgkmm;
8963 const Double_t kRearUpHookHalfBase = 25.000*fgkmm;
8964 const Double_t kRearUpHookHoleWide = 25.000*fgkmm;
8965 const Double_t kRearUpHookHoleHi = 22.500*fgkmm;
8966 const Double_t kRearUpHookHoleBase = 5.000*fgkmm;
8967 const Double_t kRearUpHookHoleR5 = 5.000*fgkmm;
8968 const Double_t kRearUpHookHoleY = 8.000*fgkmm;
8969
8970 const Int_t kNumberOfRearUpHookPts = 10;
8971 const Int_t kNumbOfRearUpHookHolePts= 5;
8972
8973 // Dimensions of the forward lower hook (0872/C/11)
8974 const Double_t kRearLwHookThick = 20.000*fgkmm;
8975 const Double_t kRearLwHookRext = 590.000*fgkmm;
8976 const Double_t kRearLwHookHiTot = 30.000*fgkmm;
8977 const Double_t kRearLwHookWide = 96.000*fgkmm;
8978
8979 const Int_t kNumberOfRearLwHookPts = 3;
8980
8981 // Dimensions of the rear lower brackets (0872/C/16)
8982 const Double_t kRearLwBracketThick = 15.000*fgkmm;
8983 const Double_t kRearLwBracketHi1 = 42.000*fgkmm;
8984 const Double_t kRearLwBracketHi2 = 12.000*fgkmm;
8985 const Double_t kRearLwBracketWide1 = 34.000*fgkmm;
8986 const Double_t kRearLwBracketWide2 = 10.000*fgkmm;
8987// const Double_t kRearLwBracketR5 = 5.000*fgkmm
8988
8989 // Dimensions of the forward webcam supports (0872/C/V/01-03-04)
8990 const Double_t kForwWebSStirrDep = 20.000*fgkmm;
8991 const Double_t kForwWebSStirrLen1 = 15.000*fgkmm;
8992 const Double_t kForwWebSStirrLen2 = 55.000*fgkmm;
8993 const Double_t kForwWebSStirrLen3 = 10.000*fgkmm;
8994 const Double_t kForwWebSStirrWide1 = 45.000*fgkmm;
8995 const Double_t kForwWebSStirrWide2 = 38.000*fgkmm;
8996 const Double_t kForwWebSStirrWide3 = 23.000*fgkmm;
8997 const Double_t kForwWebTStirrThick = 5.000*fgkmm;
8998 const Double_t kForwWebTStirrWide1 = 30.000*fgkmm;
8999 const Double_t kForwWebTStirrWide2 = 10.000*fgkmm;
9000 const Double_t kForwWebTStirrTotLen3= 58.500*fgkmm;
9001 const Double_t kForwWebTStirrTotLen4= 36.000*fgkmm;
9002 const Double_t kForwWebTStirrLen1 = 10.000*fgkmm;
9003
9004 // Dimensions of the forward and rear webcam clamps (0872/C/V/02)
9005 const Double_t kFRWebClampThick = 10.000*fgkmm;
9006 const Double_t kFRWebClampExtWide = 30.000*fgkmm;
9007 const Double_t kFRWebClampIntWide = 18.000*fgkmm;
9008 const Double_t kFRWebClampExtHi = 22.000*fgkmm;
9009 const Double_t kFRWebClampIntHi = 17.000*fgkmm;
9010
9011 // Dimensions of the webcam itself
9012 const Double_t kWebcamLength = 35.000*fgkmm;//ESTIMATED!!!
9013
9014 // Dimensions of the rear upper webcam supports (0872/C/V/05-06)
8b0d638d 9015 const Double_t kRearUpWebStirrWide = 76.000*fgkmm;
f0a991bf 9016 const Double_t kRearUpWebStirrDep = 15.000*fgkmm;
9017 const Double_t kRearUpWebStirrThick = 5.000*fgkmm;
9018 const Double_t kRearUpWebStirrH1 = 27.000*fgkmm;
9019 const Double_t kRearUpWebStirrH2 = 32.000*fgkmm;
9020 const Double_t kRearUpWebBarLen = 130.000*fgkmm;
9021 const Double_t kRearUpWebBarHi = 20.000*fgkmm;
9022 const Double_t kRearUpWebBarThick = 5.000*fgkmm;
9023
9024 // Dimensions of the upper wheel slides (0872/C/Z/00-01-02)
9025 const Double_t kUpperSlideTotHeight = 93.500*fgkmm;
9026 const Double_t kUpperSlideBlockHi = 62.500*fgkmm;
9027 const Double_t kUpperSlideWidth = 36.000*fgkmm;
9028 const Double_t kUpperSlideTotDepth = 51.000*fgkmm;
9029 const Double_t kUpperSlideIntDepth = 36.000*fgkmm;
9030 const Double_t kUpperSlideStubHi = 15.000*fgkmm;
9031 const Double_t kUpperSlideStubDep = 8.000*fgkmm;
9032 const Double_t kUpperSlideWheelHi = 18.500*fgkmm;
9033 const Double_t kUpperSlideHoleRout = 11.000*fgkmm;
9034 const Double_t kUpperSlideHoleRint1 = 9.000*fgkmm;
9035 const Double_t kUpperSlideHoleRint2 = 11.500*fgkmm;
9036 const Double_t kUpperSlideHoleH1 = 7.000*fgkmm;
9037 const Double_t kUpperSlideHoleH2 = 46.000*fgkmm;
9038 const Double_t kUpperSlideHoleH3 = 1.100*fgkmm;
9039 const Double_t kUpperSlideHoleXPos = 20.000*fgkmm;
9040 const Double_t kUpperSlidePinRmin = 4.000*fgkmm;
9041 const Double_t kUpperSlidePinRmax = 6.000*fgkmm;
9042 const Double_t kUpperSlidePinH1 = 7.000*fgkmm;
9043 const Double_t kUpperSlidePinH2 = 46.000*fgkmm;
9044 const Double_t kUpperSlidePinH3 = 25.500*fgkmm;
9045
9046 // Dimensions of the lower wheel slides (0872/C/W/00-01-02-03)
9047 const Double_t kLowerSlideTotHeight = 80.000*fgkmm;
9048 const Double_t kLowerSlideBlockHi = 28.000*fgkmm;
9049 const Double_t kLowerSlideWidth = 36.000*fgkmm;
9050 const Double_t kLowerSlideTotDepth = 60.000*fgkmm;
9051 const Double_t kLowerSlideHoleRout = 9.500*fgkmm;
9052 const Double_t kLowerSlideHoleRint = 4.700*fgkmm;
9053 const Double_t kLowerSlideHoleH1 = 12.000*fgkmm;
9054 const Double_t kLowerSlideNoseBase = 40.000*fgkmm;
9055 const Double_t kLowerSlideNoseBasHi = 6.000*fgkmm;//Computed
9056 const Double_t kLowerSlideNoseUpWid = 25.000*fgkmm;
9057 const Double_t kLowerSlideNoseDepth = 10.000*fgkmm;
9058 const Double_t kLowerSlidePinRmin = 3.000*fgkmm;
9059 const Double_t kLowerSlidePinRmax = 4.000*fgkmm;
9060 const Double_t kLowerSlidePinH1 = 12.000*fgkmm;
9061 const Double_t kLowerSlidePinH2 = 10.000*fgkmm;
9062
8b0d638d 9063 // Dimensions and positions of the C1/C2 rail stirrups (0872/C/01-02)
9064 const Double_t kStirrCXPos = 759.000*fgkmm;
9065 const Double_t kStirrCZPos = 1867.000*fgkmm;
9066
9067 const Double_t kStirrC12Thick = 15.000*fgkmm;
9068 const Double_t kStirrC12TotLen = 314.000*fgkmm;
9069 const Double_t kStirrC12BodyHalfHi = 95.000*fgkmm;
9070 const Double_t kStirrC12BodyLen = 153.000*fgkmm;
9071 const Double_t kStirrC12HeadLen = 50.000*fgkmm;
9072 const Double_t kStirrC12HeadHalfHi = 165.000*fgkmm;
9073 const Double_t kStirrC12HeadIntHi = 114.000*fgkmm;
9074 const Double_t kStirrC12HeadIntLen = 45.000*fgkmm;
9075 const Double_t kStirrC12TailLen = 14.000*fgkmm;
9076 const Double_t kStirrC12R100 = 100.000*fgkmm;
9077 const Double_t kStirrC12R50 = 50.000*fgkmm;
9078 const Double_t kStirrC12R10 = 10.000*fgkmm;
9079 const Double_t kStirrC12HeadAng = 40.000; // Degree
9080
9081 const Int_t kNumberOfStirrCPoints = 23;
9082
9083 // Dimensions and positions of the C5 rail stirrups (0872/C/05)
9084 const Double_t kStirrC5BodyLen = 155.000*fgkmm;
9085
f0a991bf 9086
9087 // Local variables
8b0d638d 9088 Double_t xprof[2*kNumberOfStirrCPoints+1],yprof[2*kNumberOfStirrCPoints+1];
f0a991bf 9089 Double_t xpos, ypos, zpos, alpha;
8b0d638d 9090 Double_t xdummy, ydummy;
f0a991bf 9091
9092
9093 // First create all needed shapes
9094
9095 // The Supporting Ring (0872/C/04): a really complex Xtru
9096 // to approximate the arc with a polyline
9097 TGeoXtru *ringC2C3 = new TGeoXtru(2);
9098
9099 for (Int_t j=0; j<11; j++) { // The external arc
9100 xprof[j] = kRingCRmax*SinD(90*j/10);
9101 yprof[j] = kRingCRmax*CosD(90*j/10);
9102 }
9103
9104 xprof[11] = kRingCRmin;
9105 yprof[11] = yprof[10];
9106
9107 alpha = TMath::ASin(kRingCYToInsert/kRingCRmin); // Now the insert
9108 xprof[12] = kRingCRmin*TMath::Cos(alpha/2);
9109 yprof[12] = kRingCRmin*TMath::Sin(alpha/2);
9110 xprof[13] = kRingCRmin*TMath::Cos(alpha);
9111 yprof[13] = kRingCRmin*TMath::Sin(alpha);
9112
9113 xprof[14] = kRingCXToInsert;
9114 yprof[14] = yprof[13];
9115
9116 alpha = TMath::ACos(kRingCXToInsert/kRingCRmin); // The insert ending angle
9117 xprof[15] = kRingCRmin*TMath::Cos(alpha);
9118 yprof[15] = kRingCRmin*TMath::Sin(alpha);
9119
9120 for (Int_t j=7; j>1; j--) { // The internal arc
9121 xprof[23-j] = kRingCRmin*SinD(90*j/10);
9122 yprof[23-j] = kRingCRmin*CosD(90*j/10);
9123 }
9124
9125 alpha = TMath::ASin(kRingCHeight/kRingCRmin); // The angle till the notch
9126 xprof[22] = kRingCRmin*TMath::Cos(alpha);
9127 yprof[22] = kRingCRmin*TMath::Sin(alpha);
9128
9129 xprof[23] = xprof[0];
9130 yprof[23] = yprof[22];
9131
9132 // We did the right side, now reflex on the left side
9133 for (Int_t jp = 0; jp < 22; jp++) {
9134 xprof[24+jp] = -xprof[23-1-jp];
9135 yprof[24+jp] = yprof[23-1-jp];
9136 }
9137
9138 // wow! now the actual Xtru
9139 ringC2C3->DefinePolygon(2*kNumberOfRingPoints, xprof, yprof);
9140 ringC2C3->DefineSection(0, 0);
9141 ringC2C3->DefineSection(1, kRingCThick);
9142
9143 // The Forward Upper Hook (0872/C/09): a Composite Shape made of
9144 // a really complex Xtru to approximate the arc with a polyline,
9145 // another Xtru for the hole, and a BBox for the hollow
9146 // The main body
9147 TGeoXtru *forwUpHookMainBody = new TGeoXtru(2);
9148 forwUpHookMainBody->SetName("ITSforwUpHookMainBody");
9149
9150 xprof[ 0] = kForwUpHookHalfBase - kForwUpHookBaseCut;
9151 yprof[ 0] = kForwUpHookRext - kForwUpHookHiTot;
9152 xprof[ 1] = kForwUpHookHalfBase;
9153 yprof[ 1] = yprof[0] + kForwUpHookBaseCut;
9154 xprof[ 2] = xprof[1];
9155 yprof[ 2] = yprof[0] + (kForwUpHookHiInt - kForwUpHookRint);
9156 for (Int_t j=1; j<6; j++) {
9157 xprof[2+j] = xprof[2] + kForwUpHookRint*(1 - CosD(90*j/5));
9158 yprof[2+j] = yprof[2] + kForwUpHookRint*SinD(90*j/5);
9159 }
9160 xprof[ 8] = kForwUpHookWide/2;
9161 yprof[ 8] = yprof[7];
9162 xprof[ 9] = xprof[8];
9163 alpha = TMath::ASin(0.5*kForwUpHookWide/kForwUpHookRext);
9164 yprof[ 9] = kForwUpHookRext*TMath::Cos(alpha);
9165 xprof[10] = kForwUpHookRext*TMath::Sin(alpha/2);
9166 yprof[10] = kForwUpHookRext*TMath::Cos(alpha/2);
9167 xprof[11] = 0;
9168 yprof[11] = kForwUpHookRext;
9169
9170 // We did the right side, now reflex on the left side
9171 for (Int_t jp = 0; jp < kNumberOfForwUpHookPts; jp++) {
9172 xprof[12+jp] = -xprof[10-jp];
9173 yprof[12+jp] = yprof[10-jp];
9174 }
9175
9176 // Now the actual Xtru
9177 forwUpHookMainBody->DefinePolygon(2*kNumberOfForwUpHookPts+1, xprof, yprof);
9178 forwUpHookMainBody->DefineSection(0, 0);
9179 forwUpHookMainBody->DefineSection(1, kForwUpHookThick);
9180
9181 // The hole
9182 TGeoXtru *forwUpHookHole = new TGeoXtru(2);
9183 forwUpHookHole->SetName("ITSforwUpHookHole");
9184
9185 xprof[0] = kForwUpHookHoleBase/2;
9186 yprof[0] = forwUpHookMainBody->GetY(0) + kForwUpHookHoleY;
9187 xprof[1] = kForwUpHookHoleWide/2;
9188 yprof[1] = yprof[0] + (xprof[1] - xprof[0]); // Go at 45deg
9189 xprof[2] = xprof[1];
9190 yprof[2] = yprof[0] + kForwUpHookHoleHi - kForwUpHookHoleR5;
9191 xprof[3] = xprof[2] - kForwUpHookHoleR5*(1 - CosD(45));
9192 yprof[3] = yprof[2] + kForwUpHookHoleR5*SinD(45);
9193 xprof[4] = xprof[2] - kForwUpHookHoleR5;
9194 yprof[4] = yprof[0] + kForwUpHookHoleHi;
9195
9196 // We did the right side, now reflex on the left side
9197 for (Int_t jp = 0; jp < kNumbOfForwUpHookHolePts; jp++) {
9198 xprof[5+jp] = -xprof[4-jp];
9199 yprof[5+jp] = yprof[4-jp];
9200 }
9201
9202 // Now the actual Xtru
9203 forwUpHookHole->DefinePolygon(2*kNumbOfForwUpHookHolePts, xprof, yprof);
9204 forwUpHookHole->DefineSection(0, -0.1);
9205 forwUpHookHole->DefineSection(1, kForwUpHookThick+0.1);
9206
9207 // The hollow
9208 TGeoBBox *forwUpHookHollow = new TGeoBBox(2.1 *kForwUpHookHalfBase,
9209 0.55*kForwUpHookHollowHi,
9210 0.55*kForwUpHookHollowWide);
9211 forwUpHookHollow->SetName("ITSforwUpHookHollow");
9212
9213 TGeoTranslation *forwUpHookHollPos = new TGeoTranslation(0.,
9214 forwUpHookMainBody->GetY(0) + 0.5*kForwUpHookHollowHi,
9215 forwUpHookMainBody->GetZ(1) - 0.5*kForwUpHookHollowWide);
9216 forwUpHookHollPos->SetName("ITSforwUpHookHollPos");
9217 forwUpHookHollPos->RegisterYourself();
9218
9219 // Finally the actual shape: a CompositeShape
9220 TGeoCompositeShape *forwUpHookShape = new TGeoCompositeShape("ITSforwUpHookMainBody-ITSforwUpHookHole-ITSforwUpHookHollow:ITSforwUpHookHollPos");
9221
9222 // The Forward Lower Hook (0872/C/08): a Composite Shape made of
9223 // a really complex Xtru to approximate the arc with a polyline,
9224 // another Xtru for the hole, and a BBox for the hollow
9225 // The main body
9226 TGeoXtru *forwLwHookMainBody = new TGeoXtru(2);
9227 forwLwHookMainBody->SetName("ITSforwLwHookMainBody");
9228
9229 xprof[ 0] = kForwLwHookHalfBase - kForwLwHookBaseCut;
9230 yprof[ 0] = kForwLwHookRext - kForwLwHookHiTot;
9231 xprof[ 1] = kForwLwHookHalfBase;
9232 yprof[ 1] = yprof[0] + kForwLwHookBaseCut;
9233 xprof[ 2] = xprof[1];
9234 yprof[ 2] = yprof[0] + (kForwLwHookHollowHi - kForwLwHookYToHollow
9235 - kForwLwHookRint);
9236 for (Int_t j=1; j<6; j++) {
9237 xprof[2+j] = xprof[2] + kForwLwHookRint*(1 - CosD(90*j/5));
9238 yprof[2+j] = yprof[2] + kForwLwHookRint*SinD(90*j/5);
9239 }
9240 xprof[ 8] = kForwLwHookWide/2;
9241 yprof[ 8] = yprof[7];
9242 xprof[ 9] = xprof[8];
9243 alpha = TMath::ASin(0.5*kForwLwHookWide/kForwLwHookRext);
9244 yprof[ 9] = kForwLwHookRext*TMath::Cos(alpha);
9245 xprof[10] = kForwLwHookRext*TMath::Sin(alpha/2);
9246 yprof[10] = kForwLwHookRext*TMath::Cos(alpha/2);
9247 xprof[11] = 0;
9248 yprof[11] = kForwLwHookRext;
9249
9250 // We did the right side, now reflex on the left side
9251 for (Int_t jp = 0; jp < kNumberOfForwLwHookPts; jp++) {
9252 xprof[12+jp] = -xprof[10-jp];
9253 yprof[12+jp] = yprof[10-jp];
9254 }
9255
9256 // Now the actual Xtru
9257 forwLwHookMainBody->DefinePolygon(2*kNumberOfForwLwHookPts+1, xprof, yprof);
9258 forwLwHookMainBody->DefineSection(0, 0);
9259 forwLwHookMainBody->DefineSection(1, kForwLwHookThick);
9260
9261 // The hole
9262 TGeoXtru *forwLwHookHole = new TGeoXtru(2);
9263 forwLwHookHole->SetName("ITSforwLwHookHole");
9264
9265 xprof[0] = 0;
9266 yprof[0] = forwLwHookMainBody->GetY(0) + kForwLwHookHoleYPos
9267 - kForwLwHookHoleR;
9268 for (Int_t j=1; j<3; j++) {
9269 xprof[0+j] = xprof[0] + kForwLwHookHoleR*SinD(90*j/3);
9270 yprof[0+j] = yprof[0] + kForwLwHookHoleR*(1 - CosD(90*j/3));
9271 }
9272 xprof[3] = xprof[0] + kForwLwHookHoleR;
9273 yprof[3] = yprof[0] + kForwLwHookHoleR;
9274 xprof[4] = xprof[3];
9275 yprof[4] = yprof[3] + kForwLwHookHoleIntHi;
9276 for (Int_t j=1; j<3; j++) {
9277 xprof[4+j] = xprof[4] - kForwLwHookHoleR*(1 - CosD(90*j/3));
9278 yprof[4+j] = yprof[4] + kForwLwHookHoleR*SinD(90*j/3);
9279 }
9280 xprof[7] = xprof[0];
9281 yprof[7] = yprof[4] + kForwLwHookHoleR;
9282
9283 // We did the right side, now reflex on the left side
9284 for (Int_t jp = 0; jp < kNumbOfForwLwHookHolePts-1; jp++) {
9285 xprof[8+jp] = -xprof[6-jp];
9286 yprof[8+jp] = yprof[6-jp];
9287 }
9288
9289 // Now the actual Xtru
9290 forwLwHookHole->DefinePolygon(2*kNumbOfForwLwHookHolePts, xprof, yprof);
9291 forwLwHookHole->DefineSection(0, -0.1);
9292 forwLwHookHole->DefineSection(1, kForwLwHookThick+0.1);
9293
9294 // The hollow
9295 TGeoBBox *forwLwHookHollow = new TGeoBBox(2.1 *kForwLwHookHalfBase,
9296 0.55*kForwLwHookHollowHi,
9297 0.55*kForwLwHookHollowWide);
9298 forwLwHookHollow->SetName("ITSforwLwHookHollow");
9299
9300 TGeoTranslation *forwLwHookHollPos = new TGeoTranslation(0.,
9301 forwLwHookMainBody->GetY(0) + 0.5*kForwLwHookHollowHi,
9302 forwLwHookMainBody->GetZ(1) - 0.5*kForwLwHookHollowWide);
9303 forwLwHookHollPos->SetName("ITSforwLwHookHollPos");
9304 forwLwHookHollPos->RegisterYourself();
9305
9306 // Finally the actual shape: a CompositeShape
9307 TGeoCompositeShape *forwLwHookShape = new TGeoCompositeShape("ITSforwLwHookMainBody-ITSforwLwHookHole-ITSforwLwHookHollow:ITSforwLwHookHollPos");
9308
9309 // The Rear Upper Hook (0872/C/10): a Composite Shape made of
9310 // a really complex Xtru to approximate the arc with a polyline,
9311 // and another Xtru for the hole
9312 // The main body
9313 TGeoXtru *rearUpHookMainBody = new TGeoXtru(2);
9314 rearUpHookMainBody->SetName("ITSrearUpHookMainBody");
9315
9316 xprof[0] = kRearUpHookHalfBase;
9317 yprof[0] = kRearUpHookRext - kRearUpHookHiTot;
9318 xprof[1] = xprof[0];
9319 yprof[1] = yprof[0] + (kRearUpHookHiInt - kRearUpHookRint);
9320 for (Int_t j=1; j<6; j++) {
9321 xprof[1+j] = xprof[1] + kRearUpHookRint*(1 - CosD(90*j/5));
9322 yprof[1+j] = yprof[1] + kRearUpHookRint*SinD(90*j/5);
9323 }
9324 xprof[ 7] = kRearUpHookWide/2;
9325 yprof[ 7] = yprof[5];
9326 xprof[ 8] = xprof[7];
9327 alpha = TMath::ASin(0.5*kRearUpHookWide/kRearUpHookRext);
9328 yprof[ 8] = kRearUpHookRext*TMath::Cos(alpha);
9329 xprof[ 9] = kRearUpHookRext*TMath::Sin(alpha/2);
9330 yprof[ 9] = kRearUpHookRext*TMath::Cos(alpha/2);
9331 xprof[10] = 0;
9332 yprof[10] = kRearUpHookRext;
9333
9334 // We did the right side, now reflex on the left side
9335 for (Int_t jp = 0; jp < kNumberOfRearUpHookPts; jp++) {
9336 xprof[11+jp] = -xprof[9-jp];
9337 yprof[11+jp] = yprof[9-jp];
9338 }
9339
9340 // Now the actual Xtru
9341 rearUpHookMainBody->DefinePolygon(2*kNumberOfRearUpHookPts+1, xprof, yprof);
9342 rearUpHookMainBody->DefineSection(0, 0);
9343 rearUpHookMainBody->DefineSection(1, kRearUpHookThick);
9344
9345 // The hole
9346 TGeoXtru *rearUpHookHole = new TGeoXtru(2);
9347 rearUpHookHole->SetName("ITSrearUpHookHole");
9348
9349 xprof[0] = kRearUpHookHoleBase/2;
9350 yprof[0] = rearUpHookMainBody->GetY(0) + kRearUpHookHoleY;
9351 xprof[1] = kRearUpHookHoleWide/2;
9352 yprof[1] = yprof[0] + (xprof[1] - xprof[0]); // Go at 45deg
9353 xprof[2] = xprof[1];
9354 yprof[2] = yprof[0] + kRearUpHookHoleHi - kRearUpHookHoleR5;
9355 xprof[3] = xprof[2] - kRearUpHookHoleR5*(1 - CosD(45));
9356 yprof[3] = yprof[2] + kRearUpHookHoleR5*SinD(45);
9357 xprof[4] = xprof[2] - kRearUpHookHoleR5;
9358 yprof[4] = yprof[0] + kRearUpHookHoleHi;
9359
9360 // We did the right side, now reflex on the left side
9361 for (Int_t jp = 0; jp < kNumbOfRearUpHookHolePts; jp++) {
9362 xprof[5+jp] = -xprof[4-jp];
9363 yprof[5+jp] = yprof[4-jp];
9364 }
9365
9366 // Now the actual Xtru
9367 rearUpHookHole->DefinePolygon(2*kNumbOfRearUpHookHolePts, xprof, yprof);
9368 rearUpHookHole->DefineSection(0, -0.1);
9369 rearUpHookHole->DefineSection(1, kRearUpHookThick+0.1);
9370
9371 // Finally the actual shape: a CompositeShape
9372 TGeoCompositeShape *rearUpHookShape = new TGeoCompositeShape("ITSrearUpHookMainBody-ITSrearUpHookHole");
9373
9374 // The Rear Lower Hook (0872/C/11): a Xtru
9375 TGeoXtru *rearLwHookShape = new TGeoXtru(2);
9376 rearLwHookShape->SetName("ITSrearLwHookShape");
9377
9378 xprof[0] = kRearLwHookWide/2;
9379 yprof[0] = kRearLwHookRext - kRearLwHookHiTot;
9380 xprof[1] = xprof[0];
9381 alpha = TMath::ASin(0.5*kRearLwHookWide/kRearLwHookRext);
9382 yprof[1] = kRearLwHookRext*TMath::Cos(alpha);
9383 xprof[2] = kRearLwHookRext*TMath::Sin(alpha/2);
9384 yprof[2] = kRearLwHookRext*TMath::Cos(alpha/2);
9385 xprof[3] = 0;
9386 yprof[3] = kRearLwHookRext;
9387
9388 // We did the right side, now reflex on the left side
9389 for (Int_t jp = 0; jp < kNumberOfRearLwHookPts; jp++) {
9390 xprof[4+jp] = -xprof[2-jp];
9391 yprof[4+jp] = yprof[2-jp];
9392 }
9393
9394 // Now the actual Xtru
9395 rearLwHookShape->DefinePolygon(2*kNumberOfRearLwHookPts+1, xprof, yprof);
9396 rearLwHookShape->DefineSection(0, 0);
9397 rearLwHookShape->DefineSection(1, kRearLwHookThick);
9398
9399 // The Rear Lower Bracket (0872/C/16): a Xtru
9400 TGeoXtru *rearLwBrackShape = new TGeoXtru(2);
9401 rearLwBrackShape->SetName("ITSrearLwBrackShape");
9402
9403 xprof[0] = 0;
9404 yprof[0] = 0;
9405 xprof[1] = xprof[0] + kRearLwBracketWide1 - kRearLwBracketWide2;
9406 yprof[1] = yprof[0];
9407 xprof[2] = xprof[1];
9408 yprof[2] = yprof[0] + kRearLwBracketHi2;
9409 xprof[3] = xprof[2] - kRearLwBracketWide1;
9410 yprof[3] = yprof[2];
9411 xprof[4] = xprof[3];
9412 yprof[4] = yprof[3] - kRearLwBracketHi1;
9413 xprof[5] = xprof[0];
9414 yprof[5] = yprof[4];
9415
9416 rearLwBrackShape->DefinePolygon(6, xprof, yprof);
9417 rearLwBrackShape->DefineSection(0,-kRearLwBracketThick/2);
9418 rearLwBrackShape->DefineSection(1, kRearLwBracketThick/2);
9419
9420 // The Forward S-shaped Stirrup for the webcam (0872/C/V/01): a Xtru
9421 TGeoXtru *forwWebSStirrSh = new TGeoXtru(2);
9422
9423 xprof[0] = 0;
9424 yprof[0] = 0;
9425 xprof[1] = xprof[0] + kForwWebSStirrLen1;
9426 yprof[1] = yprof[0];
9427 xprof[2] = xprof[1];
9428 yprof[2] = yprof[1] + kForwWebSStirrWide1;
9429 xprof[3] = xprof[0] - kForwWebSStirrLen2 + kForwWebSStirrLen3;
9430 yprof[3] = yprof[2];
9431 xprof[4] = xprof[3];
9432 yprof[4] = yprof[3] + kForwWebSStirrWide3;
9433 xprof[5] = xprof[4] - kForwWebSStirrLen3;
9434 yprof[5] = yprof[4];
9435 xprof[6] = xprof[5];
9436 yprof[6] = yprof[0] + kForwWebSStirrWide2;
9437 xprof[7] = xprof[0];
9438 yprof[7] = yprof[6];
9439
9440 forwWebSStirrSh->DefinePolygon(8, xprof, yprof);
9441 forwWebSStirrSh->DefineSection(0,-kForwWebSStirrDep/2);
9442 forwWebSStirrSh->DefineSection(1, kForwWebSStirrDep/2);
9443
9444 // The Forward T-shaped Stirrups for the webcam (0872/C/V/03-04): two Xtru
9445 TGeoXtru *forwWebTStirr3Sh = new TGeoXtru(2);
9446
9447 xprof[0] = -kForwWebTStirrWide2/2;
9448 yprof[0] = 0;
9449 xprof[1] = -kForwWebTStirrWide1/2;
9450 yprof[1] = yprof[0];
9451 xprof[2] = xprof[1];
9452 yprof[2] = yprof[1] - kForwWebTStirrLen1;
9453 xprof[3] =-xprof[2];
9454 yprof[3] = yprof[2];
9455 xprof[4] = xprof[3];
9456 yprof[4] = yprof[1];
9457 xprof[5] =-xprof[0];
9458 yprof[5] = yprof[4];
9459 xprof[6] = xprof[5];
9460 yprof[6] = kForwWebTStirrTotLen3 - kForwWebTStirrLen1;
9461 xprof[7] = xprof[0];
9462 yprof[7] = yprof[6];
9463
9464 forwWebTStirr3Sh->DefinePolygon(8, xprof, yprof);
9465 forwWebTStirr3Sh->DefineSection(0, 0);
9466 forwWebTStirr3Sh->DefineSection(1, kForwWebTStirrThick);
9467
9468 TGeoXtru *forwWebTStirr4Sh = new TGeoXtru(2);
9469
9470 yprof[6] = kForwWebTStirrTotLen4 - kForwWebTStirrLen1;
9471 yprof[7] = yprof[6];
9472
9473 forwWebTStirr4Sh->DefinePolygon(8, xprof, yprof);
9474 forwWebTStirr4Sh->DefineSection(0, 0);
9475 forwWebTStirr4Sh->DefineSection(1, kForwWebTStirrThick);
9476
9477 // The Forward and Rear clamp for the webcam (0872/C/V/02): a Xtru
9478 TGeoXtru *frWebClampSh = new TGeoXtru(2);
9479
9480 xprof[0] = kFRWebClampIntWide/2;
9481 yprof[0] = kFRWebClampIntHi;
9482 xprof[1] = xprof[0];
9483 yprof[1] = 0;
9484 xprof[2] = kFRWebClampExtWide/2;
9485 yprof[2] = yprof[1];
9486 xprof[3] = xprof[2];
9487 yprof[3] = kFRWebClampExtHi;
9488 for (Int_t jp = 0; jp < 4; jp++) {
9489 xprof[4+jp] = -xprof[3-jp];
9490 yprof[4+jp] = yprof[3-jp];
9491 }
9492
9493 frWebClampSh->DefinePolygon(8, xprof, yprof);
9494 frWebClampSh->DefineSection(0,-kFRWebClampThick/2);
9495 frWebClampSh->DefineSection(1, kFRWebClampThick/2);
9496
9497 // The Rear Upper Stirrup for the webcam (0872/C/V/05): a Xtru
9498 TGeoXtru *upWebStirrSh = new TGeoXtru(2);
9499
9500 xprof[0] = 0;
9501 yprof[0] = 0;
9502 xprof[1] = xprof[0] - (kRearUpWebStirrWide - 2*kRearUpWebStirrThick);
9503 yprof[1] = yprof[0];
9504 xprof[2] = xprof[1];
9505 yprof[2] = yprof[1] + (kRearUpWebStirrH1 - kRearUpWebStirrThick);
9506 xprof[3] = xprof[2] - kRearUpWebStirrThick;
9507 yprof[3] = yprof[2];
9508 xprof[4] = xprof[3];
9509 yprof[4] = yprof[3] - kRearUpWebStirrH1;
9510 xprof[5] = xprof[4] + kRearUpWebStirrWide;
9511 yprof[5] = yprof[4];
9512 xprof[6] = xprof[5];
9513 yprof[6] = yprof[5] + kRearUpWebStirrH2;
9514 xprof[7] = xprof[0];
9515 yprof[7] = yprof[6];
9516
9517 upWebStirrSh->DefinePolygon(8, xprof, yprof);
9518 upWebStirrSh->DefineSection(0,-kRearUpWebStirrDep/2);
9519 upWebStirrSh->DefineSection(1, kRearUpWebStirrDep/2);
9520
9521 // The Rear Upper Bar for the webcam (0872/C/V/06): a BBox
9522 TGeoBBox *upRearWebBarSh = new TGeoBBox(kRearUpWebBarLen/2,
9523 kRearUpWebBarHi/2,
9524 kRearUpWebBarThick/2);
9525
9526 // The Webcam: a BBox
9527 TGeoBBox *webcamShape = new TGeoBBox(kFRWebClampIntWide/2,
9528 kWebcamLength/2,
9529 kFRWebClampIntHi/2);
9530
9531 // The Upper Wheel Slide (0872/C/Z/00-01-02)
9532 // A mother volume of air (to avoid assembly) contains the Alluminum block
9533 // (a Composite Shape: a Xtru and a Pcon for the hole) and the Steel pin
9534 // (a Pcon) (The wheels are approximated as part of the block itself)
9535 // The Air mother volume
9536 TGeoXtru *upSlideAirSh = new TGeoXtru(2);
9537 upSlideAirSh->SetName("ITSupperSlideAirShape");
9538
9539 xprof[0] = 0;
9540 yprof[0] = 0;
9541 xprof[1] = xprof[0];
9542 yprof[1] = kUpperSlideBlockHi + kUpperSlideStubHi - kUpperSlideWheelHi;
9543 xprof[2] = xprof[1] - kUpperSlideIntDepth;
9544 yprof[2] = yprof[1];
9545 xprof[3] = xprof[2];
9546 yprof[3] = yprof[2] - kUpperSlideTotHeight;
9547 xprof[4] = xprof[3] + kUpperSlideTotDepth;
9548 yprof[4] = yprof[3];
9549 xprof[5] = xprof[4];
9550 yprof[5] = yprof[0];
9551
9552 upSlideAirSh->DefinePolygon(6, xprof, yprof);
9553 upSlideAirSh->DefineSection(0,-kUpperSlideWidth/2);
9554 upSlideAirSh->DefineSection(1, kUpperSlideWidth/2);
9555
9556 // The (filled) Aluminum block: a Xtru
9557 TGeoXtru *upSlideAluSh = new TGeoXtru(2);
9558 upSlideAluSh->SetName("ITSupperSlideAluShape");
9559
9560 xprof[0] = upSlideAirSh->GetX(0);
9561 yprof[0] = upSlideAirSh->GetY(0);
9562 xprof[1] = upSlideAirSh->GetX(1);
9563 yprof[1] = upSlideAirSh->GetY(1);
9564 xprof[2] = xprof[1] - kUpperSlideStubDep;
9565 yprof[2] = yprof[1];
9566 xprof[3] = xprof[2];
9567 yprof[3] = yprof[2] - kUpperSlideStubHi;
9568 xprof[4] = upSlideAirSh->GetX(2);
9569 yprof[4] = yprof[3];
9570 xprof[5] = xprof[4];
9571 yprof[5] = yprof[4] - kUpperSlideBlockHi;
9572 xprof[6] = upSlideAirSh->GetX(5);
9573 yprof[6] = yprof[5];
9574 xprof[7] = xprof[6];
9575 yprof[7] = yprof[0];
9576
9577 upSlideAluSh->DefinePolygon(8, xprof, yprof);
9578 upSlideAluSh->DefineSection(0, upSlideAirSh->GetZ(0));
9579 upSlideAluSh->DefineSection(1, upSlideAirSh->GetZ(1));
9580
9581 // The cylindrical hole in the block; a Pcon
9582 TGeoPcon *upSlideHoleSh = new TGeoPcon(0, 360, 10);
9583 upSlideHoleSh->SetName("ITSupperSlideHoleShape");
9584
9585 zpos = upSlideAluSh->GetY(5);
9586 upSlideHoleSh->DefineSection(0, zpos-0.1, 0, kUpperSlideHoleRout);
9587 zpos += (kUpperSlideBlockHi - kUpperSlideHoleH3 - kUpperSlideHoleH2
9588 - 2*kUpperSlideHoleH1);
9589 upSlideHoleSh->DefineSection(1, zpos, 0, kUpperSlideHoleRout);
9590 upSlideHoleSh->DefineSection(2, zpos, 0, kUpperSlideHoleRint2);
9591 zpos += kUpperSlideHoleH3;
9592 upSlideHoleSh->DefineSection(3, zpos, 0, kUpperSlideHoleRint2);
9593 upSlideHoleSh->DefineSection(4, zpos, 0, kUpperSlideHoleRout);
9594 zpos += kUpperSlideHoleH1;
9595 upSlideHoleSh->DefineSection(5, zpos, 0, kUpperSlideHoleRout);
9596 upSlideHoleSh->DefineSection(6, zpos, 0, kUpperSlideHoleRint1);
9597 zpos += kUpperSlideHoleH2;
9598 upSlideHoleSh->DefineSection(7, zpos, 0, kUpperSlideHoleRint1);
9599 upSlideHoleSh->DefineSection(8, zpos, 0, kUpperSlideHoleRout);
9600 zpos += kUpperSlideHoleH1;
9601 upSlideHoleSh->DefineSection(9, zpos+0.1, 0, kUpperSlideHoleRout);
9602
9603 TGeoCombiTrans *upSlideHolePos = new TGeoCombiTrans(-kUpperSlideHoleXPos,0,0,
9604 new TGeoRotation("",0,-90,0) );
9605 upSlideHolePos->SetName("ITSupperSlideHolePos");
9606 upSlideHolePos->RegisterYourself();
9607
9608 // The actual block: a CompositeShape
9609 TGeoCompositeShape *upSlideBlockSh = new TGeoCompositeShape("ITSupperSlideAluShape-ITSupperSlideHoleShape:ITSupperSlideHolePos");
9610
9611 // The Steel pin in the block; a Pcon
9612 TGeoPcon *upSlidePinSh = new TGeoPcon(0, 360, 6);
9613 upSlidePinSh->SetName("ITSupperSlidePinShape");
9614
9615 zpos = upSlideAluSh->GetY(5) - (kUpperSlidePinH1 + kUpperSlidePinH2
9616 + kUpperSlidePinH3 - kUpperSlideBlockHi);
9617 upSlidePinSh->DefineSection(0, zpos, 0, kUpperSlidePinRmin);
9618 zpos += kUpperSlidePinH3;
9619 upSlidePinSh->DefineSection(1, zpos, 0, kUpperSlidePinRmin);
9620 upSlidePinSh->DefineSection(2, zpos, 0, kUpperSlidePinRmax);
9621 zpos += kUpperSlidePinH2;
9622 upSlidePinSh->DefineSection(3, zpos, 0, kUpperSlidePinRmax);
9623 upSlidePinSh->DefineSection(4, zpos, 0, kUpperSlidePinRmin);
9624 zpos += kUpperSlidePinH1;
9625 upSlidePinSh->DefineSection(5, zpos, 0, kUpperSlidePinRmin);
9626
9627 // The Lower Wheel Slide (0872/C/W/00-01-02-03)
9628 // A mother volume of air (to avoid assembly) contains the Alluminum block
9629 // (a Composite Shape: a Xtru and a Pcon for the hole), the Alluminum nose
9630 // (a Xtru) and the Steel pin (a Pcon)
9631 // (The wheels are approximated as part of the block itself)
9632 // The Air mother volume
9633 TGeoXtru *lwSlideAirSh = new TGeoXtru(2);
9634 lwSlideAirSh->SetName("ITSlowerSlideAirShape");
9635
9636 xprof[0] = 0;
9637 yprof[0] = 0;
9638 xprof[1] = xprof[0] + kLowerSlideTotDepth/2 - kLowerSlideNoseBase/2;
9639 yprof[1] = yprof[0];
9640 xprof[2] = xprof[1];
9641 yprof[2] = yprof[1] - (kLowerSlideBlockHi + kLowerSlidePinH2);
9642 xprof[3] = xprof[2] - kLowerSlideTotDepth;
9643 yprof[3] = yprof[2];
9644 xprof[4] = xprof[3];
9645 yprof[4] = yprof[3] + kLowerSlidePinH2 + kLowerSlideTotHeight;
9646 xprof[5] = xprof[0];
9647 yprof[5] = yprof[4];
9648
9649 lwSlideAirSh->DefinePolygon(6, xprof, yprof);
9650 lwSlideAirSh->DefineSection(0,-kLowerSlideWidth/2);
9651 lwSlideAirSh->DefineSection(1, kLowerSlideWidth/2);
9652
9653 // The (filled) Aluminum block: a Xtru
9654 TGeoXtru *lwSlideAluSh = new TGeoXtru(2);
9655 lwSlideAluSh->SetName("ITSlowerSlideAluShape");
9656
9657 xprof[0] = lwSlideAirSh->GetX(0);
9658 yprof[0] = lwSlideAirSh->GetY(0);
9659 xprof[1] = lwSlideAirSh->GetX(1);
9660 yprof[1] = lwSlideAirSh->GetY(1);
9661 xprof[2] = xprof[1];
9662 yprof[2] = yprof[1] - kLowerSlideBlockHi;
9663 xprof[3] = lwSlideAirSh->GetX(3);
9664 yprof[3] = yprof[2];
9665 xprof[4] = xprof[3];
9666 yprof[4] = yprof[3] + kLowerSlideBlockHi;
9667 xprof[5] = xprof[4] + kLowerSlideTotDepth/2;
9668 yprof[5] = yprof[4];
9669 xprof[6] = xprof[5];
9670 yprof[6] = lwSlideAirSh->GetY(4);
9671 xprof[7] = xprof[0];
9672 yprof[7] = yprof[6];
9673
9674 lwSlideAluSh->DefinePolygon(8, xprof, yprof);
9675 lwSlideAluSh->DefineSection(0, lwSlideAirSh->GetZ(0));
9676 lwSlideAluSh->DefineSection(1, lwSlideAirSh->GetZ(1));
9677
9678 // The cylindrical hole in the block; a Pcon
9679 TGeoPcon *lwSlideHoleSh = new TGeoPcon(0, 360, 4);
9680 lwSlideHoleSh->SetName("ITSlowerSlideHoleShape");
9681
9682 zpos = lwSlideAluSh->GetY(2);
9683 lwSlideHoleSh->DefineSection(0, zpos-0.1, 0, kLowerSlideHoleRout);
9684 zpos += kLowerSlideHoleH1;
9685 lwSlideHoleSh->DefineSection(1, zpos, 0, kLowerSlideHoleRout);
9686 lwSlideHoleSh->DefineSection(2, zpos, 0, kLowerSlideHoleRint);
9687 zpos = lwSlideAluSh->GetY(4);
9688 lwSlideHoleSh->DefineSection(3, zpos, 0, kLowerSlideHoleRint);
9689
9690 TGeoCombiTrans *lwSlideHolePos = new TGeoCombiTrans(lwSlideAluSh->GetX(5),
9691 0, 0,
9692 new TGeoRotation("",0,-90,0) );
9693 lwSlideHolePos->SetName("ITSlowerSlideHolePos");
9694 lwSlideHolePos->RegisterYourself();
9695
9696 // The actual block: a CompositeShape
9697 TGeoCompositeShape *lwSlideBlockSh = new TGeoCompositeShape("ITSlowerSlideAluShape-ITSlowerSlideHoleShape:ITSlowerSlideHolePos");
9698
9699 // The Aluminum nose: a Xtru
9700 TGeoXtru *lwSlideNoseSh = new TGeoXtru(2);
9701 lwSlideNoseSh->SetName("ITSlowerSlideNoseShape");
9702
9703 xprof[0] = lwSlideAluSh->GetX(5);
9704 yprof[0] = lwSlideAluSh->GetY(5);
9705 xprof[1] = xprof[0] - kLowerSlideNoseBase/2;
9706 yprof[1] = yprof[0];
9707 xprof[2] = xprof[1];
9708 yprof[2] = yprof[1] + kLowerSlideNoseBasHi;
9709 xprof[3] = lwSlideAluSh->GetX(0) - kLowerSlideNoseUpWid;
9710 yprof[3] = lwSlideAluSh->GetY(6);
9711 xprof[4] = xprof[0];
9712 yprof[4] = yprof[3];
9713
9714 lwSlideNoseSh->DefinePolygon(5, xprof, yprof);
9715 lwSlideNoseSh->DefineSection(0,-kLowerSlideNoseDepth/2);
9716 lwSlideNoseSh->DefineSection(1, kLowerSlideNoseDepth/2);
9717
9718 // The Steel pin in the block; a Pcon
9719 TGeoPcon *lwSlidePinSh = new TGeoPcon(0, 360, 4);
9720 lwSlidePinSh->SetName("ITSlowerSlidePinShape");
9721
9722 zpos = lwSlideAirSh->GetY(2);
9723 lwSlidePinSh->DefineSection(0, zpos, 0, kLowerSlidePinRmax);
9724 zpos += kLowerSlidePinH2;
9725 lwSlidePinSh->DefineSection(1, zpos, 0, kLowerSlidePinRmax);
9726 lwSlidePinSh->DefineSection(2, zpos, 0, kLowerSlidePinRmin);
9727 zpos += kLowerSlidePinH1;
9728 lwSlidePinSh->DefineSection(3, zpos, 0, kLowerSlidePinRmin);
9729
8b0d638d 9730 // The Stirrup on the Muon side (0872/C/01-02): a really complex Xtru
9731 // to approximate arcs with polylines
9732 TGeoXtru *stirrupC1C2Sh = new TGeoXtru(2);
9733
9734 for (Int_t j=0; j<11; j++) { // The internal arc
9735 xprof[j] = kStirrC12R50*(1 - CosD(90*j/10));
9736 yprof[j] = kStirrC12R50*SinD(90*j/10);
9737 }
9738
9739 xprof[11] = xprof[10] + kStirrC12TailLen;
9740 yprof[11] = yprof[10];
9741 xprof[12] = xprof[11];
9742 yprof[12] = kStirrC12BodyHalfHi;
9743 xprof[13] = xprof[12] - kStirrC12BodyLen;
9744 yprof[13] = yprof[12];
9745
9746 xprof[17] = xprof[12] - kStirrC12TotLen + kStirrC12HeadLen;
9747 yprof[17] = kStirrC12HeadHalfHi;
9748 IntersectCircle(-TanD(kStirrC12HeadAng), xprof[17], yprof[17],
9749 kStirrC12R100, xprof[13], yprof[13]+kStirrC12R100,
9750 xprof[16], yprof[16], xdummy, ydummy);
9751 alpha = TMath::ASin((xprof[13]-xprof[16])/kStirrC12R100);
9752 xprof[14] = xprof[13] - kStirrC12R100*TMath::Sin(alpha/3);
9753 yprof[14] = yprof[13] + kStirrC12R100*(1 - TMath::Cos(alpha/3));
9754 xprof[15] = xprof[13] - kStirrC12R100*TMath::Sin(2*alpha/3);
9755 yprof[15] = yprof[13] + kStirrC12R100*(1 - TMath::Cos(2*alpha/3));
9756
9757 xprof[18] = xprof[17] - kStirrC12HeadLen;
9758 yprof[18] = yprof[17];
9759 xprof[19] = xprof[18];
9760 yprof[19] = kStirrC12HeadIntHi;
9761 xprof[20] = xprof[19] + kStirrC12HeadIntLen - kStirrC12R10;
9762 yprof[20] = yprof[19];
9763 for (Int_t j=1; j<4; j++) {
9764 xprof[20+j] = xprof[20] + kStirrC12R10*SinD(90*j/3);
9765 yprof[20+j] = yprof[20] - kStirrC12R10*(1 - CosD(90*j/3));
9766 }
9767
9768 // We did the up side, now reflex on the bottom side
9769 for (Int_t jp = 0; jp < kNumberOfStirrCPoints; jp++) {
9770 xprof[24+jp] = xprof[23-jp];
9771 yprof[24+jp] = -yprof[23-jp];
9772 }
9773
9774 // Now the actual Xtru
9775 stirrupC1C2Sh->DefinePolygon(2*kNumberOfStirrCPoints+1, xprof, yprof);
9776 stirrupC1C2Sh->DefineSection(0,-kStirrC12Thick/2);
9777 stirrupC1C2Sh->DefineSection(1, kStirrC12Thick/2);
9778
9779 // The first element of the Stirrup on the Forward side (0872/C/05):
9780 // a really complex Xtru (equal to part of the Muon Stirrup)
9781 // (0872/C/06 and 0872/C/07 are dismounted after positioning the TPC to I.P.)
9782 TGeoXtru *stirrupC5Sh = new TGeoXtru(2);
9783
9784 for (Int_t j=0; j<13; j++) { // The internal arc and the tail
9785 xprof[j] = stirrupC1C2Sh->GetX(j);
9786 yprof[j] = stirrupC1C2Sh->GetY(j);
9787 }
9788
9789 xprof[13] = xprof[12] - kStirrC5BodyLen;
9790 yprof[13] = yprof[12];
9791
9792 // We did the up side, now reflex on the bottom side
9793 for (Int_t jp = 0; jp < 13; jp++) {
9794 xprof[14+jp] = xprof[13-jp];
9795 yprof[14+jp] = -yprof[13-jp];
9796 }
9797
9798 // Now the actual Xtru
9799 stirrupC5Sh->DefinePolygon(27, xprof, yprof);
9800 stirrupC5Sh->DefineSection(0,-kStirrC12Thick/2);
9801 stirrupC5Sh->DefineSection(1, kStirrC12Thick/2);
9802
f0a991bf 9803
9804 // We have all shapes: now create the real volumes
9805 TGeoMedium *medAlcoa = mgr->GetMedium("ITS_ALUMINUM$"); // To code!!!!!!
9806 TGeoMedium *medHokotol = mgr->GetMedium("ITS_HOKOTOL$");
9807 TGeoMedium *medAnticor = mgr->GetMedium("ITS_ANTICORODAL$");
8b0d638d 9808 TGeoMedium *medErgal = mgr->GetMedium("ITS_ERGAL$");
f0a991bf 9809 TGeoMedium *medAisi = mgr->GetMedium("ITS_AISI304L$");
9810 TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
9811 TGeoMedium *medPlexy = mgr->GetMedium("ITS_PLEXYGLAS$");
9812 TGeoMedium *medPVC = mgr->GetMedium("ITS_PVC$");
9813
8b0d638d 9814
f0a991bf 9815 TGeoVolume *suppRingC2C3 = new TGeoVolume("ITSTPCsupportRingC2C3",
9816 ringC2C3, medAlcoa);
9817
9818 suppRingC2C3->SetVisibility(kTRUE);
9819 suppRingC2C3->SetLineColor(6); // Purple
9820 suppRingC2C3->SetLineWidth(1);
9821 suppRingC2C3->SetFillColor(suppRingC2C3->GetLineColor());
9822 suppRingC2C3->SetFillStyle(4000); // 0% transparent
9823
9824 TGeoVolume *forwUpHook = new TGeoVolume("ITSTPCsupportForwUpHook",
9825 forwUpHookShape, medHokotol);
9826
9827 forwUpHook->SetVisibility(kTRUE);
9828 forwUpHook->SetLineColor(6); // Purple
9829 forwUpHook->SetLineWidth(1);
9830 forwUpHook->SetFillColor(forwUpHook->GetLineColor());
9831 forwUpHook->SetFillStyle(4000); // 0% transparent
9832
9833 TGeoVolume *forwLwHook = new TGeoVolume("ITSTPCsupportForwLwHook",
9834 forwLwHookShape, medHokotol);
9835
9836 forwLwHook->SetVisibility(kTRUE);
9837 forwLwHook->SetLineColor(6); // Purple
9838 forwLwHook->SetLineWidth(1);
9839 forwLwHook->SetFillColor(forwLwHook->GetLineColor());
9840 forwLwHook->SetFillStyle(4000); // 0% transparent
9841
9842 TGeoVolume *rearUpHook = new TGeoVolume("ITSTPCsupportRearUpHook",
9843 rearUpHookShape, medHokotol);
9844
9845 rearUpHook->SetVisibility(kTRUE);
9846 rearUpHook->SetLineColor(6); // Purple
9847 rearUpHook->SetLineWidth(1);
9848 rearUpHook->SetFillColor(rearUpHook->GetLineColor());
9849 rearUpHook->SetFillStyle(4000); // 0% transparent
9850
9851 TGeoVolume *rearLwHook = new TGeoVolume("ITSTPCsupportRearLwHook",
9852 rearLwHookShape, medAnticor);
9853
9854 rearLwHook->SetVisibility(kTRUE);
9855 rearLwHook->SetLineColor(6); // Purple
9856 rearLwHook->SetLineWidth(1);
9857 rearLwHook->SetFillColor(rearLwHook->GetLineColor());
9858 rearLwHook->SetFillStyle(4000); // 0% transparent
9859
9860 TGeoVolume *rearLwBrack = new TGeoVolume("ITSTPCsupportRearLwBracket",
9861 rearLwBrackShape, medAnticor);
9862
9863 rearLwBrack->SetVisibility(kTRUE);
9864 rearLwBrack->SetLineColor(6); // Purple
9865 rearLwBrack->SetLineWidth(1);
9866 rearLwBrack->SetFillColor(rearLwBrack->GetLineColor());
9867 rearLwBrack->SetFillStyle(4000); // 0% transparent
9868
9869 TGeoVolume *forwWebSStirrup = new TGeoVolume("ITSTPCsupportForwWebSStirrup",
9870 forwWebSStirrSh, medAnticor);
9871
9872 forwWebSStirrup->SetVisibility(kTRUE);
9873 forwWebSStirrup->SetLineColor(6); // Purple
9874 forwWebSStirrup->SetLineWidth(1);
9875 forwWebSStirrup->SetFillColor(forwWebSStirrup->GetLineColor());
9876 forwWebSStirrup->SetFillStyle(4000); // 0% transparent
9877
9878 TGeoVolume *forwWebTStirr3 = new TGeoVolume("ITSTPCsupportForwWebTStirrup3",
9879 forwWebTStirr3Sh, medAnticor);
9880
9881 forwWebTStirr3->SetVisibility(kTRUE);
9882 forwWebTStirr3->SetLineColor(6); // Purple
9883 forwWebTStirr3->SetLineWidth(1);
9884 forwWebTStirr3->SetFillColor(forwWebTStirr3->GetLineColor());
9885 forwWebTStirr3->SetFillStyle(4000); // 0% transparent
9886
9887 TGeoVolume *forwWebTStirr4 = new TGeoVolume("ITSTPCsupportForwWebTStirrup4",
9888 forwWebTStirr4Sh, medAnticor);
9889
9890 forwWebTStirr4->SetVisibility(kTRUE);
9891 forwWebTStirr4->SetLineColor(6); // Purple
9892 forwWebTStirr4->SetLineWidth(1);
9893 forwWebTStirr4->SetFillColor(forwWebTStirr4->GetLineColor());
9894 forwWebTStirr4->SetFillStyle(4000); // 0% transparent
9895
9896 TGeoVolume *frWebClamp = new TGeoVolume("ITSTPCsupportForwRearWebClamp",
9897 frWebClampSh, medPlexy);
9898
9899 frWebClamp->SetVisibility(kTRUE);
9900 frWebClamp->SetLineColor(kAzure);
9901 frWebClamp->SetLineWidth(1);
9902 frWebClamp->SetFillColor(frWebClamp->GetLineColor());
9903 frWebClamp->SetFillStyle(4000); // 0% transparent
9904
9905 TGeoVolume *upWebStirrup = new TGeoVolume("ITSTPCsupportUpperWebStirrup",
9906 upWebStirrSh, medAnticor);
9907
9908 upWebStirrup->SetVisibility(kTRUE);
9909 upWebStirrup->SetLineColor(6); // Purple
9910 upWebStirrup->SetLineWidth(1);
9911 upWebStirrup->SetFillColor(upWebStirrup->GetLineColor());
9912 upWebStirrup->SetFillStyle(4000); // 0% transparent
9913
9914 TGeoVolume *upRearWebBar = new TGeoVolume("ITSTPCsupportUpperRearWebBar",
9915 upRearWebBarSh, medPlexy);
9916
9917 upRearWebBar->SetVisibility(kTRUE);
9918 upRearWebBar->SetLineColor(kAzure);
9919 upRearWebBar->SetLineWidth(1);
9920 upRearWebBar->SetFillColor(upRearWebBar->GetLineColor());
9921 upRearWebBar->SetFillStyle(4000); // 0% transparent
9922
9923 TGeoVolume *webCam = new TGeoVolume("ITSTPCsupportWebcam",
9924 webcamShape, medPVC);
9925
9926 webCam->SetVisibility(kTRUE);
9927 webCam->SetLineColor(kBlack);
9928 webCam->SetLineWidth(1);
9929 webCam->SetFillColor(webCam->GetLineColor());
9930 webCam->SetFillStyle(4000); // 0% transparent
9931
9932 TGeoVolume *upSlideVol = new TGeoVolume("ITSTPCsupportUpperSlide",
9933 upSlideAirSh, medAir);
9934
9935 upSlideVol->SetVisibility(kFALSE);
9936
9937 TGeoVolume *upSlideBlock = new TGeoVolume("ITSTPCsupportUpperSlideBlock",
9938 upSlideBlockSh, medAnticor);
9939
9940 upSlideBlock->SetVisibility(kTRUE);
9941 upSlideBlock->SetLineColor(6); // Purple
9942 upSlideBlock->SetLineWidth(1);
9943 upSlideBlock->SetFillColor(upSlideBlock->GetLineColor());
9944 upSlideBlock->SetFillStyle(4000); // 0% transparent
9945
9946 TGeoVolume *upSlidePin = new TGeoVolume("ITSTPCsupportUpperSlidePin",
9947 upSlidePinSh, medAisi);
9948
9949 upSlidePin->SetVisibility(kTRUE);
9950 upSlidePin->SetLineColor(kGray);
9951 upSlidePin->SetLineWidth(1);
9952 upSlidePin->SetFillColor(upSlidePin->GetLineColor());
9953 upSlidePin->SetFillStyle(4000); // 0% transparent
9954
9955 TGeoVolume *lwSlideVol = new TGeoVolume("ITSTPCsupportLowerSlide",
9956 lwSlideAirSh, medAir);
9957
9958 lwSlideVol->SetVisibility(kFALSE);
9959
9960 TGeoVolume *lwSlideBlock = new TGeoVolume("ITSTPCsupportLowerSlideBlock",
9961 lwSlideBlockSh, medAnticor);
9962
9963 lwSlideBlock->SetVisibility(kTRUE);
9964 lwSlideBlock->SetLineColor(6); // Purple
9965 lwSlideBlock->SetLineWidth(1);
9966 lwSlideBlock->SetFillColor(lwSlideBlock->GetLineColor());
9967 lwSlideBlock->SetFillStyle(4000); // 0% transparent
9968
9969 TGeoVolume *lwSlideNose = new TGeoVolume("ITSTPCsupportLowerSlideNose",
9970 lwSlideNoseSh, medAnticor);
9971
9972 lwSlideNose->SetVisibility(kTRUE);
9973 lwSlideNose->SetLineColor(6); // Purple
9974 lwSlideNose->SetLineWidth(1);
9975 lwSlideNose->SetFillColor(lwSlideNose->GetLineColor());
9976 lwSlideNose->SetFillStyle(4000); // 0% transparent
9977
9978 TGeoVolume *lwSlidePin = new TGeoVolume("ITSTPCsupportLowerSlidePin",
9979 lwSlidePinSh, medAisi);
9980
9981 lwSlidePin->SetVisibility(kTRUE);
9982 lwSlidePin->SetLineColor(kGray);
9983 lwSlidePin->SetLineWidth(1);
9984 lwSlidePin->SetFillColor(lwSlidePin->GetLineColor());
9985 lwSlidePin->SetFillStyle(4000); // 0% transparent
9986
8b0d638d 9987 TGeoVolume *stirrC1C2 = new TGeoVolume("ITSTPCsupportStirrupC1C2",
9988 stirrupC1C2Sh, medErgal);
9989
9990 stirrC1C2->SetVisibility(kTRUE);
9991 stirrC1C2->SetLineColor(6); // Purple
9992 stirrC1C2->SetLineWidth(1);
9993 stirrC1C2->SetFillColor(stirrC1C2->GetLineColor());
9994 stirrC1C2->SetFillStyle(4000); // 0% transparent
9995
9996 TGeoVolume *stirrC5 = new TGeoVolume("ITSTPCsupportStirrupC5",
9997 stirrupC5Sh, medErgal);
9998
9999 stirrC5->SetVisibility(kTRUE);
10000 stirrC5->SetLineColor(6); // Purple
10001 stirrC5->SetLineWidth(1);
10002 stirrC5->SetFillColor(stirrC5->GetLineColor());
10003 stirrC5->SetFillStyle(4000); // 0% transparent
10004
f0a991bf 10005
10006 // Build up the wheel slides
10007 upSlideVol->AddNode(upSlideBlock,1,0);
10008 upSlideVol->AddNode(upSlidePin, 1,
10009 new TGeoCombiTrans(-kUpperSlideHoleXPos, 0, 0,
10010 new TGeoRotation("",0,-90,0) ) );
10011
10012 lwSlideVol->AddNode(lwSlideBlock,1,0);
10013 lwSlideVol->AddNode(lwSlideNose ,1,0);
10014 lwSlideVol->AddNode(lwSlidePin, 1,
10015 new TGeoCombiTrans(lwSlideAluSh->GetX(5), 0, 0,
10016 new TGeoRotation("",0,-90,0) ) );
10017
10018
10019 // Finally put everything in the mother volume
10020 moth->AddNode(suppRingC2C3,1,
8b0d638d 10021 new TGeoTranslation(0, 0, kRingCZPos+kRingCZToTPC) );
f0a991bf 10022 moth->AddNode(suppRingC2C3,2,
10023 new TGeoCombiTrans( 0, 0,-kRingCZPos,
10024 new TGeoRotation("",0.,180.,0.) ) );
10025 moth->AddNode(suppRingC2C3,3,
8b0d638d 10026 new TGeoCombiTrans( 0, 0, kRingCZPos+kRingCZToTPC,
f0a991bf 10027 new TGeoRotation("",0.,0.,180.) ) );
10028 moth->AddNode(suppRingC2C3,4,
10029 new TGeoCombiTrans( 0, 0,-kRingCZPos,
10030 new TGeoRotation("",0.,180.,180.) ) );
10031
8b0d638d 10032 zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
f0a991bf 10033 moth->AddNode(forwUpHook,1,
10034 new TGeoTranslation( 0, 0, zpos) );
10035
8b0d638d 10036 zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
f0a991bf 10037 moth->AddNode(forwLwHook,1,
10038 new TGeoCombiTrans( 0, 0, zpos,
10039 new TGeoRotation("",0.,0.,180.) ) );
10040
10041 zpos = kRingCZPos + kRingCThick + kRearUpHookThick;
10042 moth->AddNode(rearUpHook,1,
10043 new TGeoTranslation( 0, 0,-zpos) );
10044
10045 zpos = kRingCZPos + kRingCThick + kRearLwHookThick;
10046 moth->AddNode(rearLwHook,1,
10047 new TGeoCombiTrans( 0, 0,-zpos,
10048 new TGeoRotation("",0.,0.,180.) ) );
10049
10050 xpos = kRearLwHookWide/2 + kRearLwBracketThick/2;
10051 ypos = -kRingCHeight;
10052 moth->AddNode(rearLwBrack,1,
10053 new TGeoCombiTrans( xpos, ypos,-zpos,
10054 new TGeoRotation("", 90.,-90.,-90.) ) );
10055 moth->AddNode(rearLwBrack,2,
10056 new TGeoCombiTrans(-xpos, ypos,-zpos,
10057 new TGeoRotation("", 90.,-90.,-90.) ) );
10058
10059 xpos = kForwUpHookWide/2;
10060 ypos = (forwUpHookMainBody->GetY(8) + forwUpHookMainBody->GetY(9))/2;
8b0d638d 10061 zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
f0a991bf 10062 moth->AddNode(forwWebSStirrup,1,
10063 new TGeoCombiTrans( xpos, ypos, zpos,
10064 new TGeoRotation("", 0., 90., 0.) ) );
10065 xpos = kForwLwHookWide/2;
10066 ypos = (forwLwHookMainBody->GetY(8) + forwLwHookMainBody->GetY(9))/2;
10067 moth->AddNode(forwWebSStirrup,2,
10068 new TGeoCombiTrans( xpos,-ypos, zpos,
10069 new TGeoRotation("", 0., 90., 0.) ) );
10070
10071 xpos = kForwUpHookWide/2
10072 + (forwWebSStirrSh->GetX(4) + forwWebSStirrSh->GetX(5))/2;
10073 ypos = (forwUpHookMainBody->GetY(8) + forwUpHookMainBody->GetY(9))/2
10074 + forwWebSStirrSh->GetZ(1) - forwWebTStirr3Sh->GetY(7);
10075 zpos += (forwWebSStirrSh->GetY(4) - forwWebSStirrSh->GetY(0));
10076 moth->AddNode(forwWebTStirr3,1,
10077 new TGeoTranslation( xpos, ypos, zpos) );
10078
10079 ypos -= frWebClampSh->GetZ(1);
10080 moth->AddNode(frWebClamp,1,
10081 new TGeoCombiTrans( xpos, ypos, zpos+forwWebTStirr3Sh->GetZ(1),
10082 new TGeoRotation("", 0., 90., 0.) ) );
10083
10084 ypos -= webcamShape->GetDY()/2;
10085 moth->AddNode(webCam,1,
10086 new TGeoTranslation( xpos, ypos,
10087 zpos+forwWebTStirr3Sh->GetZ(1)+webcamShape->GetDZ()) );
10088
10089 xpos = kForwLwHookWide/2
10090 + (forwWebSStirrSh->GetX(4) + forwWebSStirrSh->GetX(5))/2;
10091 ypos = (forwLwHookMainBody->GetY(8) + forwLwHookMainBody->GetY(9))/2
10092 + forwWebSStirrSh->GetZ(1) - forwWebTStirr4Sh->GetY(7);
10093 moth->AddNode(forwWebTStirr4,1,
10094 new TGeoCombiTrans( xpos,-ypos, zpos,
10095 new TGeoRotation("", 180., 0., 0.) ) );
10096
10097 ypos -= frWebClampSh->GetZ(1);
10098 moth->AddNode(frWebClamp,2,
10099 new TGeoCombiTrans( xpos,-ypos, zpos+forwWebTStirr4Sh->GetZ(1),
10100 new TGeoRotation("", 0., 90., 0.) ) );
10101
10102 ypos -= webcamShape->GetDY()/2;
10103 moth->AddNode(webCam,2,
10104 new TGeoTranslation( xpos,-ypos,
10105 zpos+forwWebTStirr4Sh->GetZ(1)+webcamShape->GetDZ()) );
5ea15037 10106
f0a991bf 10107 xpos = kRearUpHookWide/2 + kRearUpWebStirrDep/2;
10108 ypos = kRingCHeight;
10109 zpos = kRingCZPos + kRingCThick;
10110 moth->AddNode(upWebStirrup,1,
10111 new TGeoCombiTrans( xpos, ypos,-zpos,
10112 new TGeoRotation("",-90.,-90., 90.) ) );
10113 moth->AddNode(upWebStirrup,2,
10114 new TGeoCombiTrans(-xpos, ypos,-zpos,
10115 new TGeoRotation("",-90.,-90., 90.) ) );
10116
10117 ypos = kRingCHeight + upWebStirrSh->GetY(2) - upRearWebBarSh->GetDY();
10118 zpos = kRingCZPos + kRingCThick + upWebStirrSh->GetX(3)
10119 - upRearWebBarSh->GetDZ();
10120 moth->AddNode(upRearWebBar,1,
10121 new TGeoTranslation( 0, ypos,-zpos) );
10122
10123 zpos -= upRearWebBarSh->GetDZ();
10124 moth->AddNode(frWebClamp,3,
10125 new TGeoCombiTrans( 0, ypos,-zpos,
10126 new TGeoRotation("", 0., 90., 0.) ) );
10127
10128 ypos -= webcamShape->GetDY()/2;
10129 zpos -= webcamShape->GetDZ();
10130 moth->AddNode(webCam,3,
10131 new TGeoTranslation( 0, ypos,-zpos) );
5ea15037 10132
f0a991bf 10133 xpos = ringC2C3->GetX(14) + kUpperSlideWidth/2;
10134 ypos = ringC2C3->GetY(14);
10135 zpos = kRingCZPos + kRingCThick;
10136 moth->AddNode(upSlideVol,1,
8b0d638d 10137 new TGeoCombiTrans( xpos, ypos, zpos + kRingCZToTPC,
f0a991bf 10138 new TGeoRotation("",-90.,-90., 90.) ) );
10139 moth->AddNode(upSlideVol,2,
8b0d638d 10140 new TGeoCombiTrans(-xpos, ypos, zpos + kRingCZToTPC,
f0a991bf 10141 new TGeoRotation("",-90.,-90., 90.) ) );
10142 moth->AddNode(upSlideVol,3,
10143 new TGeoCombiTrans( xpos, ypos, -zpos,
10144 new TGeoRotation("", 90.,-90.,-90.) ) );
10145 moth->AddNode(upSlideVol,4,
10146 new TGeoCombiTrans(-xpos, ypos, -zpos,
10147 new TGeoRotation("", 90.,-90.,-90.) ) );
10148
10149 moth->AddNode(lwSlideVol,1,
8b0d638d 10150 new TGeoCombiTrans( xpos,-ypos, zpos + kRingCZToTPC,
10151 new TGeoRotation("", 90.,-90., 90.) ) );
10152 moth->AddNode(lwSlideVol,2,
10153 new TGeoCombiTrans(-xpos,-ypos, zpos + kRingCZToTPC,
10154 new TGeoRotation("", 90.,-90., 90.) ) );
10155 moth->AddNode(lwSlideVol,3,
f0a991bf 10156 new TGeoCombiTrans( xpos,-ypos,-zpos,
10157 new TGeoRotation("",-90.,-90.,-90.) ) );
8b0d638d 10158 moth->AddNode(lwSlideVol,4,
f0a991bf 10159 new TGeoCombiTrans(-xpos,-ypos,-zpos,
10160 new TGeoRotation("",-90.,-90.,-90.) ) );
8b0d638d 10161
10162 xpos = kStirrCXPos;
10163 zpos = kRingCZPos + kStirrCZPos + stirrupC1C2Sh->GetZ(1) + kRingCZToTPC;
10164 moth->AddNode(stirrC1C2,1,
10165 new TGeoTranslation( xpos, 0, zpos) );
10166 moth->AddNode(stirrC1C2,2,
10167 new TGeoCombiTrans(-xpos, 0, zpos,
10168 new TGeoRotation("", 90.,-180.,-90.) ) );
10169
10170 xpos = kStirrCXPos + stirrupC1C2Sh->GetX(18) + kUpperSlideWidth/2;
10171 ypos = ringC2C3->GetY(14); // Slides are all at the same height
10172 zpos = kRingCZPos + kStirrCZPos + kStirrC12Thick + kRingCZToTPC;
10173 moth->AddNode(upSlideVol,5,
10174 new TGeoCombiTrans( xpos, ypos, zpos,
10175 new TGeoRotation("",-90.,-90., 90.) ) );
10176 moth->AddNode(upSlideVol,6,
10177 new TGeoCombiTrans(-xpos, ypos, zpos,
10178 new TGeoRotation("",-90.,-90., 90.) ) );
10179 moth->AddNode(lwSlideVol,5,
f0a991bf 10180 new TGeoCombiTrans( xpos,-ypos, zpos,
10181 new TGeoRotation("", 90.,-90., 90.) ) );
8b0d638d 10182 moth->AddNode(lwSlideVol,6,
f0a991bf 10183 new TGeoCombiTrans(-xpos,-ypos, zpos,
10184 new TGeoRotation("", 90.,-90., 90.) ) );
10185
8b0d638d 10186 xpos = kStirrCXPos;
10187 zpos = kRingCZPos + kStirrCZPos + stirrupC5Sh->GetZ(1);
10188 moth->AddNode(stirrC5,1,
10189 new TGeoTranslation( xpos, 0,-zpos) );
10190 moth->AddNode(stirrC5,2,
10191 new TGeoCombiTrans(-xpos, 0,-zpos,
10192 new TGeoRotation("", 90.,-180.,-90.) ) );
10193
f0a991bf 10194
10195 return;
10196}
10197