]> 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
Add QA image (M. Siciliano, A. Mastroserio)
[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//______________________________________________________________________
a275e8ba 45void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,TGeoManager *mgr)
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
61//
62// Technical data are taken from: ALICE-Thermal Screen "Cone transition"
63// (thermal-screen1_a3.ps), "Cylinder" (thermal-screen2_a3.ps), "Half
64// assembly" (thermal-screen3_a3.ps), "Flange" (thermal-screen4_a3.ps)
65
66
67 // Dimensions of the Central shield
ddf00e3c 68 const Double_t kHalfLengthCentral = 400.*fgkmm;
a275e8ba 69 const Double_t kThicknessCentral = 0.4*fgkmm;
70 const Double_t kInnerRadiusCentral = 8.1475*fgkcm;
71 const Double_t kOuterRadiusCentral = 9.9255*fgkcm;
72 const Double_t kInnerACentral = 3.1674*fgkcm;
73 const Double_t kInnerBCentral = 2.023 *fgkcm;
74 const Double_t kOuterACentral = 2.4374*fgkcm;
75 const Double_t kOuterBCentral = 3.8162*fgkcm;
76 // Dimensions of the EndCap shield
77 const Double_t kHalfLengthEndCap = 25.*fgkmm;
78 const Double_t kThicknessEndCap = 2.0*fgkmm;
79 const Double_t kInnerRadiusEndCap = 8.0775*fgkcm;
80 const Double_t kOuterRadiusEndCap = 9.9955*fgkcm;
81 const Double_t kInnerAEndCap = 3.1453*fgkcm;
82 const Double_t kInnerBEndCap = 2.0009*fgkcm;
83 const Double_t kOuterAEndCap = 2.4596*fgkcm;
84 const Double_t kOuterBEndCap = 3.8384*fgkcm;
85 // Dimensions of the Cone shield
86 const Double_t kHalfLengthCone = 145.*fgkmm;
87 const Double_t kThicknessCone = 0.3*fgkmm;
88 const Double_t kInnerRadialCone = 37.3*fgkcm;
89 const Double_t kOuterRadialCone = 39.0*fgkcm;
90 const Double_t kInnerACone = 14.2344*fgkcm;
91 // const Double_t kInnerBCone = 9.0915*fgkcm;
92 const Double_t kOuterACone = 9.5058*fgkcm;
93 // const Double_t kOuterBCone = 14.8831*fgkcm;
94 // Dimensions of the Flange's Ring and Wing
95 const Double_t kHalfLengthRing = 7.5*fgkmm;
96 const Double_t kThicknessRing = 0.3*fgkmm;
97 const Double_t kInnerRadiusRing = 37.3*fgkcm;
98 const Double_t kOuterRadiusRing = 42.0*fgkcm;
99 const Double_t kOuterRadiusWing = 49.25*fgkcm;
ca86fdb4 100 const Double_t kWideWing = 6.0*fgkcm;
0b9c8a10 101 const Double_t kThetaWing = 45.0;
a275e8ba 102 // Common data
103 const Double_t kTheta = 36.0*TMath::DegToRad();
104 const Double_t kThicknessOmega = 0.3*fgkmm;
105
106 // Local variables
107 Double_t x, y;
108 Double_t xshld[24], yshld[24];
109 Double_t xair[24] , yair[24];
110 Double_t xomega[48], yomega[48];
111 // Double_t *xyarb8;
112
113 // The entire shield is made up of two half central shields
114 // symmetric with respect to the XZ plane, four half end cap
115 // shields, again symmetric with respect to the XZ plane, and four
116 // half cones, symmetric with respect to the XZ plane too.
117
118 TGeoVolumeAssembly *vM = new TGeoVolumeAssembly("ITSspdThermalShield");
119
120 // The central half shield: a half tube of carbon fiber,
121 // a similar but proportionally smaller half tube of air inside it,
122 // and a Omega-shaped carbon fiber insert inside the air.
123 // They are all XTru shapes
124
125 TGeoXtru *centralshape = new TGeoXtru(2);
126
127 CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
128 kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
129 kTheta,xshld,yshld);
130
131 centralshape->DefinePolygon(24,xshld,yshld);
132 centralshape->DefineSection(0,-kHalfLengthCentral);
133 centralshape->DefineSection(1, kHalfLengthCentral);
134
135 // Now rescale to get the air volume dimensions
136 InsidePoint(xshld[23], yshld[23],
137 xshld[ 0], yshld[ 0],
138 xshld[ 1], yshld[ 1], kThicknessCentral,
139 xair[0], yair[0]);
140 for (Int_t i=1; i<23; i++) {
141 InsidePoint(xshld[i-1], yshld[i-1],
142 xshld[ i ], yshld[ i ],
143 xshld[i+1], yshld[i+1], kThicknessCentral,
144 xair[i], yair[i]);
145 }
146 InsidePoint(xshld[22], yshld[22],
147 xshld[23], yshld[23],
148 xshld[ 0], yshld[ 0], kThicknessCentral,
149 xair[23], yair[23]);
150
151 // Create the air shape
152 TGeoXtru *centralairshape = new TGeoXtru(2);
153
154 centralairshape->DefinePolygon(24,xair,yair);
155 centralairshape->DefineSection(0,-kHalfLengthCentral);
156 centralairshape->DefineSection(1, kHalfLengthCentral);
157
158 // Create the Omega insert
159 TGeoXtru *centralomegashape = new TGeoXtru(2);
160
3d2705b6 161 CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
a275e8ba 162
163 centralomegashape->DefinePolygon(48,xomega,yomega);
164 centralomegashape->DefineSection(0,-kHalfLengthCentral);
165 centralomegashape->DefineSection(1, kHalfLengthCentral);
166
167 // The end cap half shield: a half tube of carbon fiber,
168 // a similar but proportionally smaller half tube of air inside it,
169 // and a Omega-shaped carbon fiber insert inside the air.
170 // They are all XTru shapes
171
172 TGeoXtru *endcapshape = new TGeoXtru(2);
173
174 CreateSPDThermalShape(kInnerAEndCap,kInnerBEndCap,kInnerRadiusEndCap,
175 kOuterAEndCap,kOuterBEndCap,kOuterRadiusEndCap,
176 kTheta,xshld,yshld);
177
178 endcapshape->DefinePolygon(24,xshld,yshld);
179 endcapshape->DefineSection(0,-kHalfLengthEndCap);
180 endcapshape->DefineSection(1, kHalfLengthEndCap);
181
182 // Now rescale to get the air volume dimensions
183 InsidePoint(xshld[23], yshld[23],
184 xshld[ 0], yshld[ 0],
185 xshld[ 1], yshld[ 1], kThicknessEndCap,
186 xair[0], yair[0]);
187 for (Int_t i=1; i<23; i++) {
188 InsidePoint(xshld[i-1], yshld[i-1],
189 xshld[ i ], yshld[ i ],
190 xshld[i+1], yshld[i+1], kThicknessEndCap,
191 xair[i], yair[i]);
192 }
193 InsidePoint(xshld[22], yshld[22],
194 xshld[23], yshld[23],
195 xshld[ 0], yshld[ 0], kThicknessEndCap,
196 xair[23], yair[23]);
197
198 // Create the air shape
199 TGeoXtru *endcapairshape = new TGeoXtru(2);
200
201 endcapairshape->DefinePolygon(24,xair,yair);
202 endcapairshape->DefineSection(0,-kHalfLengthEndCap);
203 endcapairshape->DefineSection(1, kHalfLengthEndCap);
204
205 // Create the Omega insert
206 TGeoXtru *endcapomegashape = new TGeoXtru(2);
207
3d2705b6 208 CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
a275e8ba 209
210 endcapomegashape->DefinePolygon(48,xomega,yomega);
211 endcapomegashape->DefineSection(0,-kHalfLengthEndCap);
212 endcapomegashape->DefineSection(1, kHalfLengthEndCap);
213
214 // The cone half shield is more complex since there is no basic
215 // TGeo shape to describe it correctly. So it is made of a series
216 // of TGeoArb8 shapes filled with air, which all together make up the
217 // the cone AND its internal insert. Part of the following code is
218 // adapted from SPDThermalSheald method.
219
220 // Filled portions
221 TGeoArb8 *sC1 = new TGeoArb8(kHalfLengthCone);
222 TGeoArb8 *sC2 = new TGeoArb8(kHalfLengthCone);
223
224 CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
225 kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
226 kTheta,xshld,yshld);
227
228 sC1->SetVertex(0,xshld[12],yshld[12]);
229 sC1->SetVertex(1,xshld[11],yshld[11]);
230 sC1->SetVertex(2,xshld[ 0],yshld[ 0]);
231 sC1->SetVertex(3,xshld[23],yshld[23]);
232
233 sC2->SetVertex(0,xshld[11],yshld[11]);
234 sC2->SetVertex(1,xshld[10],yshld[10]);
235 sC2->SetVertex(2,xshld[ 1],yshld[ 1]);
236 sC2->SetVertex(3,xshld[ 0],yshld[ 0]);
237
238 // Drawings give only the radius, convert it to the apothegm
239 Double_t kInnerRadiusCone = TMath::Sqrt(kInnerRadialCone*kInnerRadialCone
240 - 0.25*kInnerACone*kInnerACone);
241 Double_t kOuterRadiusCone = TMath::Sqrt(kOuterRadialCone*kOuterRadialCone
242 - 0.25*kOuterACone*kOuterACone);
243
244 Double_t xco[4], yco[4], xci[4], yci[4];
245
246 for (Int_t i=0; i<2; i++) {
247 Double_t th = i*kTheta*TMath::RadToDeg();
248 xco[2*i ] = kOuterRadiusCone*SinD(th) - 0.5*kOuterACone*CosD(th);
249 yco[2*i ] = kOuterRadiusCone*CosD(th) + 0.5*kOuterACone*SinD(th);
250 xci[2*i ] = kInnerRadiusCone*SinD(th) - 0.5*kInnerACone*CosD(th);
251 yci[2*i ] = kInnerRadiusCone*CosD(th) + 0.5*kInnerACone*SinD(th);
252 xco[2*i+1] = kOuterRadiusCone*SinD(th) + 0.5*kOuterACone*CosD(th);
253 yco[2*i+1] = kOuterRadiusCone*CosD(th) - 0.5*kOuterACone*SinD(th);
254 xci[2*i+1] = kInnerRadiusCone*SinD(th) + 0.5*kInnerACone*CosD(th);
255 yci[2*i+1] = kInnerRadiusCone*CosD(th) - 0.5*kInnerACone*SinD(th);
256 }
257
258 sC1->SetVertex(4,xco[0],yco[0]);
259 sC1->SetVertex(5,xco[1],yco[1]);
260 sC1->SetVertex(6,xci[1],yci[1]);
261 sC1->SetVertex(7,xci[0],yci[0]);
262
263 sC2->SetVertex(4,xco[1],yco[1]);
264 sC2->SetVertex(5,xco[2],yco[2]);
265 sC2->SetVertex(6,xci[2],yci[2]);
266 sC2->SetVertex(7,xci[1],yci[1]);
267
268 // Air holes
269 TGeoArb8 *sCh1 = new TGeoArb8(kHalfLengthCone);
270 TGeoArb8 *sCh2 = new TGeoArb8(kHalfLengthCone);
271
272 for(Int_t i=0; i<4; i++){
273 InsidePoint(sC1->GetVertices()[((i+3)%4)*2+0],
274 sC1->GetVertices()[((i+3)%4)*2+1],
275 sC1->GetVertices()[i*2+0],
276 sC1->GetVertices()[i*2+1],
277 sC1->GetVertices()[((i+1)%4)*2+0],
278 sC1->GetVertices()[((i+1)%4)*2+1],-kThicknessCone,x,y);
279 sCh1->SetVertex(i,x,y);
280
281 InsidePoint(sC1->GetVertices()[((i+3)%4 +4)*2+0],
282 sC1->GetVertices()[((i+3)%4 +4)*2+1],
283 sC1->GetVertices()[(i+4)*2+0],
284 sC1->GetVertices()[(i+4)*2+1],
285 sC1->GetVertices()[((i+1)%4 +4)*2+0],
286 sC1->GetVertices()[((i+1)%4 +4)*2+1],-kThicknessCone,x,y);
287 sCh1->SetVertex(i+4,x,y);
288
289 InsidePoint(sC2->GetVertices()[((i+3)%4)*2+0],
290 sC2->GetVertices()[((i+3)%4)*2+1],
291 sC2->GetVertices()[i*2+0],
292 sC2->GetVertices()[i*2+1],
293 sC2->GetVertices()[((i+1)%4)*2+0],
294 sC2->GetVertices()[((i+1)%4)*2+1],-kThicknessCone,x,y);
295 sCh2->SetVertex(i,x,y);
296
297 InsidePoint(sC2->GetVertices()[((i+3)%4 +4)*2+0],
298 sC2->GetVertices()[((i+3)%4 +4)*2+1],
299 sC2->GetVertices()[(i+4)*2+0],
300 sC2->GetVertices()[(i+4)*2+1],
301 sC2->GetVertices()[((i+1)%4 +4)*2+0],
302 sC2->GetVertices()[((i+1)%4 +4)*2+1],-kThicknessCone,x,y);
303 sCh2->SetVertex(i+4,x,y);
304 }
305
306 // Finally the carbon fiber Ring with its Wings and their
307 // stesalite inserts. They are Tube and TubeSeg shapes
308
309 TGeoTube *ringshape = new TGeoTube(kInnerRadiusRing,kOuterRadiusRing,
310 kHalfLengthRing);
311
312 TGeoTube *ringinsertshape = new TGeoTube(kInnerRadiusRing+kThicknessRing,
313 kOuterRadiusRing-kThicknessRing,
314 kHalfLengthRing-kThicknessRing);
315
316 Double_t angleWideWing, angleWideWingThickness;
317 angleWideWing = (kWideWing/kOuterRadiusWing)*TMath::RadToDeg();
318 angleWideWingThickness = (kThicknessRing/kOuterRadiusWing)*TMath::RadToDeg();
319
320 TGeoTubeSeg *wingshape = new TGeoTubeSeg(kOuterRadiusRing,kOuterRadiusWing,
321 kHalfLengthRing, 0, angleWideWing);
322
323 TGeoTubeSeg *winginsertshape = new TGeoTubeSeg(kOuterRadiusRing,
324 kOuterRadiusWing-kThicknessRing, kHalfLengthRing-kThicknessRing,
325 angleWideWingThickness, angleWideWing-angleWideWingThickness);
326
327
328 // We have the shapes: now create the real volumes
329
330 TGeoMedium *medSPDcf = mgr->GetMedium("ITS_SPD shield$");
331 TGeoMedium *medSPDair = mgr->GetMedium("ITS_SPD AIR$");
332 TGeoMedium *medSPDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
333
334 TGeoVolume *centralshield = new TGeoVolume("SPDcentralshield",
335 centralshape,medSPDcf);
336 centralshield->SetVisibility(kTRUE);
337 centralshield->SetLineColor(7);
338 centralshield->SetLineWidth(1);
339
340 TGeoVolume *centralairshield = new TGeoVolume("SPDcentralairshield",
341 centralairshape,medSPDair);
342 centralairshield->SetVisibility(kTRUE);
343 centralairshield->SetLineColor(5); // Yellow
344 centralairshield->SetLineWidth(1);
345 centralairshield->SetFillColor(centralairshield->GetLineColor());
346 centralairshield->SetFillStyle(4090); // 90% transparent
347
348 TGeoVolume *centralomega = new TGeoVolume("SPDcentralomega",
349 centralomegashape,medSPDcf);
350 centralomega->SetVisibility(kTRUE);
351 centralomega->SetLineColor(7);
352 centralomega->SetLineWidth(1);
353
354 centralairshield->AddNode(centralomega,1,0);
355 centralshield->AddNode(centralairshield,1,0);
356
357 TGeoVolume *endcapshield = new TGeoVolume("SPDendcapshield",
358 endcapshape,medSPDcf);
359 endcapshield->SetVisibility(kTRUE);
360 endcapshield->SetLineColor(7);
361 endcapshield->SetLineWidth(1);
362
363 TGeoVolume *endcapairshield = new TGeoVolume("SPDendcapairshield",
364 endcapairshape,medSPDair);
365 endcapairshield->SetVisibility(kTRUE);
366 endcapairshield->SetLineColor(5); // Yellow
367 endcapairshield->SetLineWidth(1);
368 endcapairshield->SetFillColor(endcapairshield->GetLineColor());
369 endcapairshield->SetFillStyle(4090); // 90% transparent
370
371 TGeoVolume *endcapomega = new TGeoVolume("SPDendcapomega",
372 endcapomegashape,medSPDcf);
373 endcapomega->SetVisibility(kTRUE);
374 endcapomega->SetLineColor(7);
375 endcapomega->SetLineWidth(1);
376
377 endcapairshield->AddNode(endcapomega,1,0);
378 endcapshield->AddNode(endcapairshield,1,0);
379
380 TGeoVolume *vC1 = new TGeoVolume("SPDconeshieldV1",sC1,medSPDcf);
381 vC1->SetVisibility(kTRUE);
382 vC1->SetLineColor(7);
383 vC1->SetLineWidth(1);
384
385 TGeoVolume *vCh1 = new TGeoVolume("SPDconeshieldH1",sCh1,medSPDair);
386
387 vCh1->SetVisibility(kTRUE);
388 vCh1->SetLineColor(5); // Yellow
389 vCh1->SetLineWidth(1);
390 vCh1->SetFillColor(vCh1->GetLineColor());
391 vCh1->SetFillStyle(4090); // 90% transparent
392
393 vC1->AddNode(vCh1,1,0);
394
395 TGeoVolume *vC2 = new TGeoVolume("SPDconeshieldV2",sC2,medSPDcf);
396
397 vC2->SetVisibility(kTRUE);
398 vC2->SetLineColor(7);
399 vC2->SetLineWidth(1);
400
401 TGeoVolume *vCh2 = new TGeoVolume("SPDconeshieldH2",sCh2,medSPDair);
402
403 vCh2->SetVisibility(kTRUE);
404 vCh2->SetLineColor(5); // Yellow
405 vCh2->SetLineWidth(1);
406 vCh2->SetFillColor(vCh2->GetLineColor());
407 vCh2->SetFillStyle(4090); // 90% transparent
408
409 vC2->AddNode(vCh2,1,0);
410
411 TGeoVolume *ring = new TGeoVolume("SPDshieldring",ringshape,medSPDcf);
412 ring->SetVisibility(kTRUE);
413 ring->SetLineColor(7);
414 ring->SetLineWidth(1);
415
416 TGeoVolume *ringinsert = new TGeoVolume("SPDshieldringinsert",
417 ringinsertshape,medSPDste);
418 ringinsert->SetVisibility(kTRUE);
419 ringinsert->SetLineColor(3); // Green
420// ringinsert->SetLineWidth(1);
421 ringinsert->SetFillColor(ringinsert->GetLineColor());
422 ringinsert->SetFillStyle(4010); // 10% transparent
423
424 ring->AddNode(ringinsert,1,0);
425
426 TGeoVolume *wing = new TGeoVolume("SPDshieldringwing",wingshape,medSPDcf);
427 wing->SetVisibility(kTRUE);
428 wing->SetLineColor(7);
429 wing->SetLineWidth(1);
430
431 TGeoVolume *winginsert = new TGeoVolume("SPDshieldringinsert",
432 winginsertshape,medSPDste);
433 winginsert->SetVisibility(kTRUE);
434 winginsert->SetLineColor(3); // Green
435// winginsert->SetLineWidth(1);
436 winginsert->SetFillColor(winginsert->GetLineColor());
437 winginsert->SetFillStyle(4010); // 10% transparent
438
439 wing->AddNode(winginsert,1,0);
440
441
442 // Add all volumes in the assembly
443 vM->AddNode(centralshield,1,0);
444 vM->AddNode(centralshield,2,new TGeoRotation("",180,0,0));
445
446 vM->AddNode(endcapshield,1,
447 new TGeoTranslation(0,0, kHalfLengthCentral+kHalfLengthEndCap));
448 vM->AddNode(endcapshield,2,
449 new TGeoTranslation(0,0,-kHalfLengthCentral-kHalfLengthEndCap));
450 vM->AddNode(endcapshield,3,new TGeoCombiTrans(
451 0, 0, kHalfLengthCentral+kHalfLengthEndCap,
452 new TGeoRotation("",180,0,0) ) );
453 vM->AddNode(endcapshield,4,new TGeoCombiTrans(
454 0, 0,-kHalfLengthCentral-kHalfLengthEndCap,
455 new TGeoRotation("",180,0,0) ) );
456
457 for (Int_t i=0; i<10; i++) {
458 Double_t thetaC12 = kTheta*TMath::RadToDeg();
459 vM->AddNode(vC1,2*i+1, new TGeoCombiTrans(
460 0, 0, kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone,
461 new TGeoRotation("",0, 0,i*thetaC12) ) );
462 vM->AddNode(vC1,2*i+2, new TGeoCombiTrans(
463 0, 0, -kHalfLengthCentral-2*kHalfLengthEndCap-kHalfLengthCone,
464 new TGeoRotation("",0,180,i*thetaC12) ) );
465 vM->AddNode(vC2,2*i+1, new TGeoCombiTrans(
466 0, 0, kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone,
467 new TGeoRotation("",0, 0,i*thetaC12) ) );
468 vM->AddNode(vC2,2*i+2, new TGeoCombiTrans(
469 0, 0, -kHalfLengthCentral-2*kHalfLengthEndCap-kHalfLengthCone,
470 new TGeoRotation("",0,180,i*thetaC12) ) );
471 }
472
473 vM->AddNode(ring,1,new TGeoTranslation(0, 0,
474 kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
475 +kHalfLengthRing));
476 vM->AddNode(ring,2,new TGeoTranslation(0, 0,
477 -kHalfLengthCentral-2*kHalfLengthEndCap-2*kHalfLengthCone
478 -kHalfLengthRing));
479
0b9c8a10 480 for (Int_t i=0; i<4; i++) {
481 Double_t thetaW = kThetaWing*(2*i+1) - angleWideWing/2.;
482 vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0,
a275e8ba 483 kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
484 +kHalfLengthRing, new TGeoRotation("",thetaW,0,0) ));
0b9c8a10 485 vM->AddNode(wing,2*i+2,new TGeoCombiTrans(0, 0,
a275e8ba 486 -kHalfLengthCentral-2*kHalfLengthEndCap-2*kHalfLengthCone
487 -kHalfLengthRing, new TGeoRotation("",thetaW,0,0) ));
488 }
489
490 // Some debugging if requested
491 if(GetDebug(1)){
492 vM->PrintNodes();
493 vM->InspectShape();
494 }
495
496 // Finally put the entire shield in the mother volume
497 moth->AddNode(vM,1,0);
498
499 return;
500}
501
502//______________________________________________________________________
503void AliITSv11GeometrySupport::CreateSPDThermalShape(
504 Double_t ina, Double_t inb, Double_t inr,
505 Double_t oua, Double_t oub, Double_t our,
506 Double_t t, Double_t *x , Double_t *y )
507{
508//
509// Creates the proper sequence of X and Y coordinates to determine
510// the base XTru polygon for the SPD thermal shapes
511//
512// Input:
513// ina, inb : inner shape sides
514// inr : inner radius
515// oua, oub : outer shape sides
516// our : outer radius
517// t : theta angle
518//
519// Output:
520// x, y : coordinate vectors [24]
521//
522// Created: 14 Nov 2007 Mario Sitta
523// Updated: 11 Dec 2007 Mario Sitta
524//
525 Double_t xlocal[6],ylocal[6];
526
527 //Create the first inner quadrant (X > 0)
528 FillSPDXtruShape(ina,inb,inr,t,xlocal,ylocal);
529 for (Int_t i=0; i<6; i++) {
530 x[i] = xlocal[i];
531 y[i] = ylocal[i];
532 }
533
534 // Then reflex on the second quadrant (X < 0)
535 for (Int_t i=0; i<6; i++) {
536 x[23-i] = -x[i];
537 y[23-i] = y[i];
538 }
539
540 // Now create the first outer quadrant (X > 0)
541 FillSPDXtruShape(oua,oub,our,t,xlocal,ylocal);
542 for (Int_t i=0; i<6; i++) {
543 x[11-i] = xlocal[i];
544 y[11-i] = ylocal[i];
545 }
546
547 // Finally reflex on the second quadrant (X < 0)
548 for (Int_t i=0; i<6; i++) {
549 x[12+i] = -x[11-i];
550 y[12+i] = y[11-i];
551 }
552
553 return;
554}
555
556//______________________________________________________________________
557void AliITSv11GeometrySupport::CreateSPDOmegaShape(
3d2705b6 558 Double_t *xin, Double_t *yin, Double_t d,
559 Double_t *x, Double_t *y)
a275e8ba 560{
561//
562// Creates the proper sequence of X and Y coordinates to determine
563// the SPD Omega XTru polygon
564//
565// Input:
566// xin, yin : coordinates of the air volume
567// d : Omega shape thickness
568// t : theta angle
569//
570// Output:
571// x, y : coordinate vectors [48]
572//
573// Created: 17 Nov 2007 Mario Sitta
574// Updated: 11 Dec 2007 Mario Sitta
3d2705b6 575// Updated: 20 Feb 2009 Mario Sitta New algorithm (the old one
576// gives erroneous vertexes)
a275e8ba 577//
a275e8ba 578
3d2705b6 579 // This vector contains the index of those points which coincide
580 // with the corresponding points in the air shape
581 Int_t indexAir2Omega[12] = {1, 2, 5, 6, 9, 10, 11, 15, 16, 19, 20, 23};
a275e8ba 582
3d2705b6 583 // First fill those vertexes corresponding to
584 // the edges aligned to the air shape edges
585 for (Int_t j=0; j<12; j++) {
586 x[*(indexAir2Omega+j)] = xin[j];
587 y[*(indexAir2Omega+j)] = yin[j];
588 }
a275e8ba 589
3d2705b6 590 // Now get the coordinates of the first inner point
591 PointFromParallelLines(x[23],y[23],x[1],y[1],d,x[0],y[0]);
a275e8ba 592
3d2705b6 593 // Knowing this, the second internal point can be determined
594 InsidePoint(x[0],y[0],x[1],y[1],x[2],y[2],d,x[22],y[22]);
a275e8ba 595
3d2705b6 596 // The third point is now computable
597 ReflectPoint(x[1],y[1],x[2],y[2],x[22],y[22],x[21],y[21]);
a275e8ba 598
3d2705b6 599 // Repeat this logic
600 InsidePoint(x[21],y[21],x[20],y[20],x[19],y[19],-d,x[3],y[3]);
a275e8ba 601
3d2705b6 602 ReflectPoint(x[20],y[20],x[19],y[19],x[3],y[3],x[4],y[4]);
a275e8ba 603
3d2705b6 604 InsidePoint(x[4],y[4],x[5],y[5],x[6],y[6],d,x[18],y[18]);
a275e8ba 605
3d2705b6 606 ReflectPoint(x[5],y[5],x[6],y[6],x[18],y[18],x[17],y[17]);
a275e8ba 607
3d2705b6 608 InsidePoint(x[17],y[17],x[16],y[16],x[15],y[15],-d,x[7],y[7]);
a275e8ba 609
3d2705b6 610 ReflectPoint(x[16],y[16],x[15],y[15],x[7],y[7],x[8],y[8]);
a275e8ba 611
3d2705b6 612 InsidePoint(x[8],y[8],x[9],y[9],x[10],y[10],d,x[14],y[14]);
a275e8ba 613
614 // These need to be fixed explicitly
a275e8ba 615 x[12] = x[11];
616 y[12] = y[11] + d;
617 x[13] = x[10] + d;
618 y[13] = y[12];
619
3d2705b6 620 // Finally reflect on the negative side
a275e8ba 621 for (Int_t i=0; i<24; i++) {
622 x[24+i] = -x[23-i];
623 y[24+i] = y[23-i];
624 }
625
626 // Wow ! We've finished
627 return;
172b0d90 628}
a275e8ba 629
172b0d90 630//______________________________________________________________________
a275e8ba 631void AliITSv11GeometrySupport::FillSPDXtruShape(Double_t a, Double_t b,
632 Double_t r, Double_t t,
633 Double_t *x, Double_t *y)
634{
635//
636// Creates the partial sequence of X and Y coordinates to determine
637// the lateral part of the SPD thermal shield
638//
639// Input:
640// a, b : shape sides
641// r : radius
642// t : theta angle
643//
644// Output:
645// x, y : coordinate vectors [6]
646//
647// Created: 14 Nov 2007 Mario Sitta
648//
649 x[0] = a/2;
650 y[0] = r;
651
652 x[1] = x[0] + b * TMath::Cos(t/2);
653 y[1] = y[0] - b * TMath::Sin(t/2);
654
655 x[2] = x[1] + a * TMath::Cos(t);
656 y[2] = y[1] - a * TMath::Sin(t);
657
658 x[3] = x[2] + b * TMath::Cos(3*t/2);
659 y[3] = y[2] - b * TMath::Sin(3*t/2);
660
661 x[4] = x[3] + a * TMath::Cos(2*t);
662 y[4] = y[3] - a * TMath::Sin(2*t);
663
664 x[5] = x[4];
665 y[5] = 0.;
666
667 return;
172b0d90 668}
a275e8ba 669
3d2705b6 670//______________________________________________________________________
671void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1,
672 Double_t x2, Double_t y2, Double_t d,
673 Double_t &x, Double_t &y)
674{
675//
676// Determines the X and Y of the first internal point of the Omega shape
677// (i.e. the coordinates of a point given two parallel lines passing by
678// two points and placed at a known distance)
679//
680// Input:
681// x1, y1 : first point
682// x2, y2 : second point
683// d : distance between the two lines
684//
685// Output:
686// x, y : coordinate of the point
687//
688// Created: 22 Feb 2009 Mario Sitta
689//
690//Begin_Html
691/*
692<img src="ITS/doc/PointFromParallelLines.gif">
693*/
694//End_Html
695
696 // The slope of the paralles lines at a distance d
697 Double_t m;
698
699 // The parameters of the solving equation
700 // a x^2 - 2 b x + c = 0
701 Double_t a = (x1 - x2)*(x1 - x2) - d*d;
702 Double_t b = (x1 - x2)*(y1 - y2);
703 Double_t c = (y1 - y2)*(y1 - y2) - d*d;
704
705 // (Delta4 is Delta/4 because we use the reduced formula)
706 Double_t Delta4 = b*b - a*c;
707
708 // Compute the slope of the two parallel lines
709 // (one of the two possible slopes, the one with the smaller
710 // absolute value is needed)
711 if (Delta4 < 0) { // Should never happen with our data, but just to be sure
712 x = -1; // x is expected positive, so this flags an error
713 return;
714 } else
715 m = (b + TMath::Sqrt(Delta4))/a; // b is negative with our data
716
717 // Finally compute the coordinates of the point
718 x = x2 + (y1 - y2 - d)/m;
719 y = y1 - d;
720
721 // Done
722 return;
723}
724
725//______________________________________________________________________
726void AliITSv11GeometrySupport::ReflectPoint(Double_t x1, Double_t y1,
727 Double_t x2, Double_t y2,
728 Double_t x3, Double_t y3,
729 Double_t &x, Double_t &y)
730{
731//
732// Given two points (x1,y1) and (x2,y2), determines the point (x,y)
733// lying on the line parallel to the line passing by these points,
734// at a distance d and passing by the point (x3,y3), which is symmetric to
735// the third point with respect to the axis of the segment delimited by
736// the two first points.
737//
738// Input:
739// x1, y1 : first point
740// x2, y2 : second point
741// x3, y3 : third point
742// d : distance between the two lines
743//
744// Output:
745// x, y : coordinate of the reflected point
746//
747// Created: 22 Feb 2009 Mario Sitta
748//
749//Begin_Html
750/*
751<img src="ITS/doc/ReflectPoint.gif">
752*/
753//End_Html
754
755 // The slope of the line passing by the first two points
756 Double_t k = (y2 - y1)/(x2 - x1);
757
758 // The middle point of the segment 1-2
759 Double_t xK = (x1 + x2)/2.;
760 Double_t yK = (y1 + y2)/2.;
761
762 // The intercept between the axis of the segment 1-2 and the line
763 // passing by 3 and parallel to the line passing by 1-2
764 Double_t xH = (k*k*x3 + k*(yK - y3) + xK)/(k*k + 1);
765 Double_t yH = k*(xH - x3) + y3;
766
767 // The point symmetric to 3 with respect to H
768 x = 2*xH - x3;
769 y = 2*yH - y3;
770
771 // Done
772 return;
773}
774
172b0d90 775//______________________________________________________________________
7d6c23de 776void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
777{
778//
779// Creates the SDD support cone and cylinder geometry as a
780// volume assembly and adds it to the mother volume
781// (part of this code is taken or anyway inspired to SDDCone method
782// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
783//
784// Input:
785// moth : the TGeoVolume owing the volume structure
786// mgr : the GeoManager (default gGeoManager)
787// Output:
788//
789// Created: ??? Bjorn S. Nilsen
790// Updated: 18 Feb 2008 Mario Sitta
6b99a08f 791// Updated: 25 Jul 2008 Mario Sitta SDDCarbonFiberCone simpler
96eb8210 792// Updated: 10 Jun 2010 Mario Sitta Cables across cone holes added
7d6c23de 793//
794// Technical data are taken from: "Supporto Generale Settore SDD"
795// (technical drawings ALR-0816/1-B), "Supporto Globale Settore SDD"
796// (technical drawings ALR-0816/2A, ALR-0816/2B, ALR-0816/2C, ALR-0816/2D),
797// private communication with B. Giraudo
798
799 // Dimensions of the Central cylinder and flanges
800 const Double_t kCylinderHalfLength = (790.0/2)*fgkmm;
801 const Double_t kCylinderInnerR = (210.0/2)*fgkmm;
802 const Double_t kCylinderOuterR = (231.0/2)*fgkmm;
803 const Double_t kFlangeHalfLength = ( 15.0/2)*fgkmm;
804 const Double_t kFlangeInnerR = (210.5/2)*fgkmm;
805 const Double_t kFlangeOuterR = (230.5/2)*fgkmm;
806 const Double_t kInsertoHalfLength =
807 kCylinderHalfLength - 2*kFlangeHalfLength;
808// const Double_t kCFThickness = kFlangeInnerR - kCylinderInnerR;
809 const Double_t kBoltDiameter = 6.0*fgkmm; // M6 screw
810 const Double_t kBoltDepth = 6.0*fgkmm; // In the flange
811 const Double_t kBoltRadius = (220.0/2)*fgkmm; // Radius in flange
812 const Double_t kThetaBolt = 30.0*fgkDegree;
813 const Int_t kNBolts = (Int_t)(360.0/kThetaBolt);
814 // Dimensions of the Cone
815 const Double_t kConeROutMin = (540.0/2)*fgkmm;
816 const Double_t kConeROutMax = (560.0/2)*fgkmm;
3a299c65 817 const Double_t kConeRCurv = 10.0*fgkmm; // Radius of curvature
7d6c23de 818 const Double_t kConeRinMin = (210.0/2)*fgkmm;
6b99a08f 819// const Double_t kConeRinMax = (216.0/2)*fgkmm;
7d6c23de 820 const Double_t kConeRinCylinder = (231.0/2)*fgkmm;
3a299c65 821 const Double_t kConeZCylinder = 192.0*fgkmm;
7d6c23de 822 const Double_t kConeZOuterMilled = 23.0*fgkmm;
823 const Double_t kConeDZin = 15.0*fgkmm; // ???
3a299c65 824 const Double_t kConeThickness = 10.0*fgkmm; // Rohacell + Carb.Fib.
7d6c23de 825 const Double_t kConeTheta = 45.0*fgkDegree; // SDD cone angle
826 const Double_t kSinConeTheta =
827 TMath::Sin(kConeTheta*TMath::DegToRad());
828 const Double_t kCosConeTheta =
829 TMath::Cos(kConeTheta*TMath::DegToRad());
830 const Double_t kTanConeTheta =
831 TMath::Tan(kConeTheta*TMath::DegToRad());
832 // Dimensions of the Cone Inserts
96eb8210 833 const Double_t kConeCFThickness = 1.5*fgkmm;//Carbon fiber thickness
7d6c23de 834 // Dimensions of the Cone Holes
835 const Double_t kHole1RMin = (450.0/2)*fgkmm;
3a299c65 836 const Double_t kHole1RMax = (530.0/2)*fgkmm;
7d6c23de 837 const Double_t kHole2RMin = (280.0/2)*fgkmm;
838 const Double_t kHole2RMax = (375.0/2)*fgkmm;
839 const Double_t kHole1Phi = 25.0*fgkDegree;
840 const Double_t kHole2Phi = 50.0*fgkDegree;
841 const Double_t kHole3RMin = 205.0*fgkmm;
842 const Double_t kHole3DeltaR = 15*fgkmm;
843 const Double_t kHole3Width = 30*fgkmm;
844 const Int_t kNHole3 = 6 ;
845 const Double_t kHole4RMin = 116.0*fgkmm;
846 const Double_t kHole4DeltaR = 15*fgkmm;
3a299c65 847 const Double_t kHole4Width = 30*fgkmm;
848 // const Int_t kNHole4 = 3 ;
96eb8210 849 // Fraction of materials in holes
850 const Double_t kHolePlasticFrac = 0.55846;
851 const Double_t kHoleCuFrac = 0.06319;
852 const Double_t kHoleGlassFrac = 0.02652;
7d6c23de 853
854 // Local variables
855 Double_t x, y, z, t, dza, rmin, rmax;
856
857
7d6c23de 858 // Recover the needed materials
96eb8210 859 TGeoMedium *medSDDcf = mgr->GetMedium("ITS_SDD C (M55J)$");
860 TGeoMedium *medSDDair = mgr->GetMedium("ITS_SDD AIR$");
861 TGeoMedium *medSDDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
862 TGeoMedium *medSDDroh = mgr->GetMedium("ITS_ROHACELL$");
863 TGeoMedium *medSDDss = mgr->GetMedium("ITS_INOX$");
864 TGeoMedium *medSDDplast = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
865 TGeoMedium *medSDDCu = mgr->GetMedium("ITS_COPPER$");
866 TGeoMedium *medSDDglass = mgr->GetMedium("ITS_SDD OPTICFIB$");
7d6c23de 867
868 // First define the geometrical shapes
869
870 // Central cylinder with its internal foam and the lateral flanges:
871 // a carbon fiber Tube which contains a rohacell Tube and two
872 // stesalite Tube's
873 TGeoTube *cylindershape = new TGeoTube(kCylinderInnerR,kCylinderOuterR,
874 kCylinderHalfLength);
875
876 TGeoTube *insertoshape = new TGeoTube(kFlangeInnerR,kFlangeOuterR,
877 kInsertoHalfLength);
878
879 TGeoTube *flangeshape = new TGeoTube(kFlangeInnerR,kFlangeOuterR,
880 kFlangeHalfLength);
881
882 // The flange bolt: it is a Tube
883 TGeoTube *boltshape = new TGeoTube(0.0, 0.5*kBoltDiameter, 0.5*kBoltDepth);
884
885 // Debug if requested
886 if (GetDebug(1)) {
887 cylindershape->InspectShape();
888 insertoshape->InspectShape();
889 flangeshape->InspectShape();
890 boltshape->InspectShape();
891 }
892
893
894 // We have the shapes: now create the real volumes
895
896 TGeoVolume *cfcylinder = new TGeoVolume("SDDCarbonFiberCylinder",
897 cylindershape,medSDDcf);
898 cfcylinder->SetVisibility(kTRUE);
899 cfcylinder->SetLineColor(4); // Blue
900 cfcylinder->SetLineWidth(1);
901 cfcylinder->SetFillColor(cfcylinder->GetLineColor());
902 cfcylinder->SetFillStyle(4000); // 0% transparent
903
904 TGeoVolume *foamcylinder = new TGeoVolume("SDDFoamCylinder",
905 insertoshape,medSDDroh);
906 foamcylinder->SetVisibility(kTRUE);
907 foamcylinder->SetLineColor(3); // Green
908 foamcylinder->SetLineWidth(1);
909 foamcylinder->SetFillColor(foamcylinder->GetLineColor());
910 foamcylinder->SetFillStyle(4050); // 50% transparent
911
912 TGeoVolume *flangecylinder = new TGeoVolume("SDDFlangeCylinder",
913 flangeshape,medSDDste);
914 flangecylinder->SetVisibility(kTRUE);
915 flangecylinder->SetLineColor(2); // Red
916 flangecylinder->SetLineWidth(1);
917 flangecylinder->SetFillColor(flangecylinder->GetLineColor());
918 flangecylinder->SetFillStyle(4050); // 50% transparent
919
920 TGeoVolume *bolt = new TGeoVolume("SDDFlangeBolt",boltshape,medSDDss);
921 bolt->SetVisibility(kTRUE);
922 bolt->SetLineColor(1); // Black
923 bolt->SetLineWidth(1);
924 bolt->SetFillColor(bolt->GetLineColor());
925 bolt->SetFillStyle(4050); // 50% transparent
926
927 // Mount up the cylinder
928 for(Int_t i=0; i<kNBolts; i++){
929 t = kThetaBolt*i;
aa177c73 930 x = kBoltRadius*CosD(t);
931 y = kBoltRadius*SinD(t);
7d6c23de 932 z = kFlangeHalfLength-kBoltDepth;
933 flangecylinder->AddNode(bolt, i+1, new TGeoTranslation("",x,y,z));
934 }
935
936 cfcylinder->AddNode(foamcylinder,1,0);
937 cfcylinder->AddNode(flangecylinder,1,
938 new TGeoTranslation(0, 0, kInsertoHalfLength+kFlangeHalfLength));
939 cfcylinder->AddNode(flangecylinder,2,new TGeoCombiTrans(
940 0, 0, -kInsertoHalfLength-kFlangeHalfLength,
941 new TGeoRotation("",0,180,0) ) );
942
943
944 // SDD Support Cone with its internal inserts: a carbon fiber Pcon
945 // with holes which contains a stesalite Pcon which on turn contains a
946 // rohacell Pcon
947
948 dza = kConeThickness/kSinConeTheta-(kConeROutMax-kConeROutMin)/kTanConeTheta;
949
6b99a08f 950 TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 10);
7d6c23de 951
952 coneshape->Z(0) = 0.0;
953 coneshape->Rmin(0) = kConeROutMin;
954 coneshape->Rmax(0) = kConeROutMax;
955
956 coneshape->Z(1) = kConeZOuterMilled - dza;
957 coneshape->Rmin(1) = coneshape->GetRmin(0);
958 coneshape->Rmax(1) = coneshape->GetRmax(0);
959
960 coneshape->Z(2) = kConeZOuterMilled;
961 coneshape->Rmax(2) = coneshape->GetRmax(0);
962
963 RadiusOfCurvature(kConeRCurv,0.,coneshape->GetZ(1),
964 coneshape->GetRmin(1),kConeTheta,z,rmin);
965 coneshape->Z(3) = z;
966 coneshape->Rmin(3) = rmin;
967
968 coneshape->Rmin(2) = RminFrom2Points(coneshape,3,1,coneshape->GetZ(2));
969
970 RadiusOfCurvature(kConeRCurv,0.,coneshape->GetZ(2),
971 coneshape->GetRmax(2),kConeTheta,z,rmax);
972 coneshape->Z(4) = z;
973 coneshape->Rmax(4) = rmax;
974 coneshape->Rmin(4) = RminFromZpCone(coneshape,3,kConeTheta,
975 coneshape->GetZ(4),0.0);
976
977 coneshape->Rmax(3) = RmaxFrom2Points(coneshape,4,2,coneshape->GetZ(3));
978
6b99a08f 979 coneshape->Z(6) = kConeZCylinder - kConeDZin;
980
981 RadiusOfCurvature(kConeRCurv,90.0,coneshape->GetZ(6),0.0,
982 90.0-kConeTheta,z,rmin);
983 coneshape->Z(5) = z;
984 coneshape->Rmin(5) = RminFromZpCone(coneshape,3,kConeTheta,z);
985 coneshape->Rmax(5) = RmaxFromZpCone(coneshape,4,kConeTheta,z);
986
987 RadiusOfCurvature(kConeRCurv,90.-kConeTheta,
988 0.0,coneshape->Rmin(5),90.0,z,rmin);
989 coneshape->Rmin(6) = rmin;
990 coneshape->Rmax(6) = RmaxFromZpCone(coneshape,4,kConeTheta,
991 coneshape->GetZ(6));
992
993 coneshape->Z(7) = coneshape->GetZ(6);
7d6c23de 994 coneshape->Rmin(7) = kConeRinMin;
6b99a08f 995 coneshape->Rmax(7) = coneshape->GetRmax(6);
7d6c23de 996
997 coneshape->Rmin(8) = kConeRinMin;
998
6b99a08f 999 RadiusOfCurvature(kConeRCurv,90.0,kConeZCylinder,kConeRinCylinder,
1000 90.0-kConeTheta,z,rmax);
1001 coneshape->Z(8) = z;
7d6c23de 1002 coneshape->Rmax(8) = rmax;
7d6c23de 1003
1004 coneshape->Z(9) = kConeZCylinder;
1005 coneshape->Rmin(9) = kConeRinMin;
6b99a08f 1006 coneshape->Rmax(9) = kConeRinCylinder;
7d6c23de 1007
7d6c23de 1008
1009 // SDD Cone Insert: another Pcon
1010 Double_t x0, y0, x1, y1, x2, y2;
1011 TGeoPcon *coneinsertshape = new TGeoPcon(0.0, 360.0, 9);
1012
1013 coneinsertshape->Z(0) = coneshape->GetZ(0) + kConeCFThickness;
1014 coneinsertshape->Rmin(0) = coneshape->GetRmin(0) + kConeCFThickness;
1015 coneinsertshape->Rmax(0) = coneshape->GetRmax(0) - kConeCFThickness;
1016
1017 x0 = coneshape->GetZ(0); y0 = coneshape->GetRmin(0);
1018 x1 = coneshape->GetZ(1); y1 = coneshape->GetRmin(1);
1019 x2 = coneshape->GetZ(2); y2 = coneshape->GetRmin(2);
1020 InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin);
1021 coneinsertshape->Z(1) = z;
1022 coneinsertshape->Rmin(1) = rmin;
1023 coneinsertshape->Rmax(1) = coneinsertshape->GetRmax(0);
1024
1025 x0 = coneshape->GetZ(1); y0 = coneshape->GetRmax(1);
1026 x1 = coneshape->GetZ(2); y1 = coneshape->GetRmax(2);
1027 x2 = coneshape->GetZ(3); y2 = coneshape->GetRmax(3);
1028 InsidePoint(x0, y0, x1, y1, x2, y2, -kConeCFThickness, z, rmax);
1029 coneinsertshape->Z(2) = z;
1030 coneinsertshape->Rmax(2) = rmax;
1031
1032 x0 = coneshape->GetZ(2); y0 = coneshape->GetRmin(2);
1033 x1 = coneshape->GetZ(3); y1 = coneshape->GetRmin(3);
1034 x2 = coneshape->GetZ(4); y2 = coneshape->GetRmin(4);
1035 InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin);
1036 coneinsertshape->Z(3) = z;
1037 coneinsertshape->Rmin(3) = rmin;
1038
1039 x0 = coneinsertshape->GetZ(1); y0 = coneinsertshape->GetRmin(1);
1040 x1 = coneinsertshape->GetZ(3); y1 = coneinsertshape->GetRmin(3);
1041 coneinsertshape->Rmin(2) = Yfrom2Points(x0, y0, x1, y1,
1042 coneinsertshape->Z(2));
1043
1044 x0 = coneshape->GetZ(3); y0 = coneshape->GetRmax(3);
1045 x1 = coneshape->GetZ(4); y1 = coneshape->GetRmax(4);
1046 x2 = coneshape->GetZ(5); y2 = coneshape->GetRmax(5);
1047 InsidePoint(x0, y0, x1, y1, x2, y2, -kConeCFThickness, z, rmax);
1048 coneinsertshape->Z(4) = z;
1049 coneinsertshape->Rmax(4) = rmax;
1050
1051 x0 = coneinsertshape->GetZ(2); y0 = coneinsertshape->GetRmax(2);
1052 x1 = coneinsertshape->GetZ(4); y1 = coneinsertshape->GetRmax(4);
1053 coneinsertshape->Rmax(3) = Yfrom2Points(x0, y0, x1, y1,
1054 coneinsertshape->Z(3));
1055
1056 x0 = coneshape->GetZ(4); y0 = coneshape->GetRmin(4);
1057 x1 = coneshape->GetZ(5); y1 = coneshape->GetRmin(5);
1058 x2 = coneshape->GetZ(6); y2 = coneshape->GetRmin(6);
1059 InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin);
1060 coneinsertshape->Z(5) = z;
1061 coneinsertshape->Rmin(5) = rmin;
1062 coneinsertshape->Rmax(5) = coneinsertshape->GetRmax(4) -
1063 kTanConeTheta*(coneinsertshape->GetZ(5) - coneinsertshape->GetZ(4));
1064
1065 x0 = coneinsertshape->GetZ(3); y0 = coneinsertshape->GetRmin(3);
1066 x1 = coneinsertshape->GetZ(5); y1 = coneinsertshape->GetRmin(5);
1067 coneinsertshape->Rmin(4) = Yfrom2Points(x0, y0, x1, y1,
1068 coneinsertshape->Z(4));
1069
1070 x0 = coneshape->GetZ(5); y0 = coneshape->GetRmin(5);
1071 x1 = coneshape->GetZ(6); y1 = coneshape->GetRmin(6);
1072 x2 = coneshape->GetZ(7); y2 = coneshape->GetRmin(7);
1073 InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin);
1074 coneinsertshape->Z(6) = z;
1075 coneinsertshape->Rmin(6) = rmin;
1076 coneinsertshape->Rmax(6) = coneinsertshape->GetRmax(4) -
1077 kTanConeTheta*(coneinsertshape->GetZ(6) - coneinsertshape->GetZ(4));
1078
1079 coneinsertshape->Z(7) = coneinsertshape->GetZ(6);
1080 coneinsertshape->Rmin(7) = coneshape->GetRmin(7) + kConeCFThickness;
1081 coneinsertshape->Rmax(7) = coneinsertshape->GetRmax(6);
1082
1083 coneinsertshape->Z(8) = coneshape->GetZ(9) - kConeCFThickness;
1084 coneinsertshape->Rmin(8) = coneinsertshape->GetRmin(7);
1085 coneinsertshape->Rmax(8) = coneinsertshape->GetRmax(4) -
1086 kTanConeTheta*(coneinsertshape->GetZ(8) - coneinsertshape->GetZ(4));
1087
1088 // SDD Cone Foam: another Pcon
1089 TGeoPcon *conefoamshape = new TGeoPcon(0.0, 360.0, 4);
1090
1091 RadiusOfCurvature(kConeRCurv+kConeCFThickness,0.0,coneinsertshape->GetZ(1),
1092 coneinsertshape->GetRmin(1),kConeTheta,z,rmin);
1093
1094 conefoamshape->Z(0) = z;
1095 conefoamshape->Rmin(0) = rmin;
1096 conefoamshape->Rmax(0) = conefoamshape->GetRmin(0);
1097
1098 conefoamshape->Z(1) = conefoamshape->GetZ(0)+
1099 (kConeThickness-2.0*kConeCFThickness)/kSinConeTheta;
1100 conefoamshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1101 conefoamshape->GetZ(1));
1102 conefoamshape->Rmax(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1103 conefoamshape->GetZ(1));
1104
1105 conefoamshape->Z(2) = coneshape->GetZ(5)-kConeCFThickness;
1106 conefoamshape->Rmin(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1107 conefoamshape->GetZ(2));
1108 conefoamshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1109 conefoamshape->GetZ(2));
1110
1111 conefoamshape->Z(3) = coneinsertshape->GetZ(5)+
1112 (kConeThickness-2.0*kConeCFThickness)*kCosConeTheta;
1113 conefoamshape->Rmax(3) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1114 conefoamshape->GetZ(3));
1115 conefoamshape->Rmin(3) = conefoamshape->GetRmax(3);
1116
1117 // SDD Cone Holes: Pcon's
a30e33f0 1118 // A single hole volume gives an overlap with coneinsert, so
1119 // three contiguous volumes are created: one to be put in the cone foam
1120 // and two in the cone carbon fiber envelope
7d6c23de 1121 TGeoPcon *hole1shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1122
1123 hole1shape->Rmin(0) = kHole1RMax;
1124 hole1shape->Rmax(0) = hole1shape->GetRmin(0);
a30e33f0 1125 hole1shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta,
7d6c23de 1126 hole1shape->GetRmin(0));
1127
1128 hole1shape->Rmax(1) = hole1shape->GetRmax(0);
a30e33f0 1129 hole1shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1130 hole1shape->GetRmax(1));
a30e33f0 1131 hole1shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
7d6c23de 1132 hole1shape->GetZ(1));
1133
1134 hole1shape->Rmin(2) = kHole1RMin;
a30e33f0 1135 hole1shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
7d6c23de 1136 hole1shape->GetRmin(2));
a30e33f0 1137 hole1shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
7d6c23de 1138 hole1shape->GetZ(2));
1139
1140 hole1shape->Rmin(3) = hole1shape->GetRmin(2);
1141 hole1shape->Rmax(3) = hole1shape->GetRmin(3);
a30e33f0 1142 hole1shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1143 hole1shape->GetRmax(3));
1144
a30e33f0 1145 TGeoPcon *hole11shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1146
1147 hole11shape->Rmin(0) = kHole1RMax;
1148 hole11shape->Rmax(0) = hole11shape->GetRmin(0);
1149 hole11shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
1150 hole11shape->GetRmin(0));
1151
1152 hole11shape->Rmax(1) = hole11shape->GetRmax(0);
1153 hole11shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1154 hole11shape->GetRmax(1));
1155 hole11shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1156 hole11shape->GetZ(1));
1157
1158 hole11shape->Rmin(2) = kHole1RMin;
1159 hole11shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
1160 hole11shape->GetRmin(2));
1161 hole11shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1162 hole11shape->GetZ(2));
1163
1164 hole11shape->Rmin(3) = hole11shape->GetRmin(2);
1165 hole11shape->Rmax(3) = hole11shape->GetRmin(3);
1166 hole11shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1167 hole11shape->GetRmax(3));
1168
1169 TGeoPcon *hole12shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1170
1171 hole12shape->Rmin(0) = kHole1RMax;
1172 hole12shape->Rmax(0) = hole12shape->GetRmin(0);
1173 hole12shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1174 hole12shape->GetRmin(0));
1175
1176 hole12shape->Rmax(1) = hole12shape->GetRmax(0);
1177 hole12shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1178 hole12shape->GetRmax(1));
1179 hole12shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1180 hole12shape->GetZ(1));
1181
1182 hole12shape->Rmin(2) = kHole1RMin;
1183 hole12shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1184 hole12shape->GetRmin(2));
1185 hole12shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1186 hole12shape->GetZ(2));
1187
1188 hole12shape->Rmin(3) = hole12shape->GetRmin(2);
1189 hole12shape->Rmax(3) = hole12shape->GetRmin(3);
1190 hole12shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1191 hole12shape->GetRmax(3));
1192
1193 //
7d6c23de 1194 TGeoPcon *hole2shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1195
1196 hole2shape->Rmin(0) = kHole2RMax;
1197 hole2shape->Rmax(0) = hole2shape->GetRmin(0);
a30e33f0 1198 hole2shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta,
7d6c23de 1199 hole2shape->GetRmin(0));
1200
1201 hole2shape->Rmax(1) = hole2shape->GetRmax(0);
a30e33f0 1202 hole2shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1203 hole2shape->GetRmax(1));
a30e33f0 1204 hole2shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
7d6c23de 1205 hole2shape->GetZ(1));
1206
1207 hole2shape->Rmin(2) = kHole2RMin;
a30e33f0 1208 hole2shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
7d6c23de 1209 hole2shape->GetRmin(2));
a30e33f0 1210 hole2shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
7d6c23de 1211 hole2shape->GetZ(2));
1212
1213 hole2shape->Rmin(3) = hole2shape->GetRmin(2);
1214 hole2shape->Rmax(3) = hole2shape->GetRmin(3);
a30e33f0 1215 hole2shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1216 hole2shape->GetRmax(3));
1217
a30e33f0 1218 TGeoPcon *hole21shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1219
1220 hole21shape->Rmin(0) = kHole2RMax;
1221 hole21shape->Rmax(0) = hole21shape->GetRmin(0);
1222 hole21shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
1223 hole21shape->GetRmin(0));
1224
1225 hole21shape->Rmax(1) = hole21shape->GetRmax(0);
1226 hole21shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1227 hole21shape->GetRmax(1));
1228 hole21shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1229 hole21shape->GetZ(1));
1230
1231 hole21shape->Rmin(2) = kHole2RMin;
1232 hole21shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
1233 hole21shape->GetRmin(2));
1234 hole21shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1235 hole21shape->GetZ(2));
1236
1237 hole21shape->Rmin(3) = hole21shape->GetRmin(2);
1238 hole21shape->Rmax(3) = hole21shape->GetRmin(3);
1239 hole21shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1240 hole21shape->GetRmax(3));
1241
1242 TGeoPcon *hole22shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1243
1244 hole22shape->Rmin(0) = kHole2RMax;
1245 hole22shape->Rmax(0) = hole22shape->GetRmin(0);
1246 hole22shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1247 hole22shape->GetRmin(0));
1248
1249 hole22shape->Rmax(1) = hole22shape->GetRmax(0);
1250 hole22shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1251 hole22shape->GetRmax(1));
1252 hole22shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1253 hole22shape->GetZ(1));
1254
1255 hole22shape->Rmin(2) = kHole2RMin;
1256 hole22shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1257 hole22shape->GetRmin(2));
1258 hole22shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1259 hole22shape->GetZ(2));
1260
1261 hole22shape->Rmin(3) = hole22shape->GetRmin(2);
1262 hole22shape->Rmax(3) = hole22shape->GetRmin(3);
1263 hole22shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1264 hole22shape->GetRmax(3));
1265
1266 //
7d6c23de 1267 Double_t holePhi;
1268 holePhi = (kHole3Width/kHole3RMin)*TMath::RadToDeg();
1269
1270 TGeoPcon *hole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1271
1272 hole3shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
1273 hole3shape->Rmax(0) = hole3shape->GetRmin(0);
a30e33f0 1274 hole3shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta,
7d6c23de 1275 hole3shape->GetRmin(0));
1276
1277 hole3shape->Rmax(1) = hole3shape->GetRmax(0);
a30e33f0 1278 hole3shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1279 hole3shape->GetRmax(1));
a30e33f0 1280 hole3shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
7d6c23de 1281 hole3shape->GetZ(1));
1282
1283 hole3shape->Rmin(2) = kHole3RMin;
a30e33f0 1284 hole3shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
7d6c23de 1285 hole3shape->GetRmin(2));
a30e33f0 1286 hole3shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
7d6c23de 1287 hole3shape->GetZ(2));
1288
1289 hole3shape->Rmin(3) = hole3shape->GetRmin(2);
1290 hole3shape->Rmax(3) = hole3shape->GetRmin(3);
a30e33f0 1291 hole3shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1292 hole3shape->GetRmax(3));
1293
a30e33f0 1294 TGeoPcon *hole31shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1295
1296 hole31shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
1297 hole31shape->Rmax(0) = hole31shape->GetRmin(0);
1298 hole31shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
1299 hole31shape->GetRmin(0));
1300
1301 hole31shape->Rmax(1) = hole31shape->GetRmax(0);
1302 hole31shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1303 hole31shape->GetRmax(1));
1304 hole31shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1305 hole31shape->GetZ(1));
1306
1307 hole31shape->Rmin(2) = kHole3RMin;
1308 hole31shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
1309 hole31shape->GetRmin(2));
1310 hole31shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1311 hole31shape->GetZ(2));
1312
1313 hole31shape->Rmin(3) = hole31shape->GetRmin(2);
1314 hole31shape->Rmax(3) = hole31shape->GetRmin(3);
1315 hole31shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1316 hole31shape->GetRmax(3));
1317
1318 TGeoPcon *hole32shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1319
1320 hole32shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
1321 hole32shape->Rmax(0) = hole32shape->GetRmin(0);
1322 hole32shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1323 hole32shape->GetRmin(0));
1324
1325 hole32shape->Rmax(1) = hole32shape->GetRmax(0);
1326 hole32shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1327 hole32shape->GetRmax(1));
1328 hole32shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1329 hole32shape->GetZ(1));
1330
1331 hole32shape->Rmin(2) = kHole3RMin;
1332 hole32shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1333 hole32shape->GetRmin(2));
1334 hole32shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1335 hole32shape->GetZ(2));
1336
1337 hole32shape->Rmin(3) = hole32shape->GetRmin(2);
1338 hole32shape->Rmax(3) = hole32shape->GetRmin(3);
1339 hole32shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1340 hole32shape->GetRmax(3));
1341
1342 //
3a299c65 1343 holePhi = (kHole4Width/kHole4RMin)*TMath::RadToDeg();
1344
7d6c23de 1345 TGeoPcon *hole4shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1346
1347 hole4shape->Rmin(0) = kHole4RMin + kHole4DeltaR;
1348 hole4shape->Rmax(0) = hole4shape->GetRmin(0);
1349 hole4shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
1350 hole4shape->GetRmin(0));
1351
1352 hole4shape->Rmax(1) = hole4shape->GetRmax(0);
1353 hole4shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1354 hole4shape->GetRmax(1));
1355 hole4shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1356 hole4shape->GetZ(1));
1357
1358 hole4shape->Rmin(2) = kHole4RMin;
1359 hole4shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
1360 hole4shape->GetRmin(2));
1361 hole4shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1362 hole4shape->GetZ(2));
1363
1364 hole4shape->Rmin(3) = hole4shape->GetRmin(2);
1365 hole4shape->Rmax(3) = hole4shape->GetRmin(3);
1366 hole4shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1367 hole4shape->GetRmax(3));
1368
96eb8210 1369 // Cables to be put inside the holes: Pcon's
1370 // (fractions are manually computed from AliITSv11GeometrySDD::SDDCables
1371 TGeoPcon *hole1plastshape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1372
1373 hole1plastshape->Rmin(0) = hole1shape->GetRmin(0);
1374 hole1plastshape->Rmax(0) = hole1shape->GetRmax(0);
1375 hole1plastshape->Z(0) = hole1shape->GetZ(0);
1376
1377 hole1plastshape->Rmin(1) = hole1shape->GetRmin(1);
1378 hole1plastshape->Rmax(1) = hole1shape->GetRmax(1);
1379 hole1plastshape->Z(1) = hole1shape->GetZ(1);
1380
1381 dza = hole1plastshape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHolePlasticFrac;
1382
1383 hole1plastshape->Rmin(2) = dza;
1384 hole1plastshape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
1385 hole1plastshape->GetRmin(2));
1386 hole1plastshape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
1387 hole1plastshape->GetZ(2));
1388
1389 hole1plastshape->Rmin(3) = hole1plastshape->GetRmin(2);
1390 hole1plastshape->Rmax(3) = hole1plastshape->GetRmin(3);
1391 hole1plastshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1392 hole1plastshape->GetRmax(3));
1393
1394 TGeoPcon *hole1Cushape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1395
1396 hole1Cushape->Rmin(0) = hole1plastshape->GetRmin(2);
1397 hole1Cushape->Rmax(0) = hole1Cushape->GetRmin(0);
1398 hole1Cushape->Z(0) = hole1plastshape->GetZ(2);
1399
1400 dza = hole1Cushape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHoleCuFrac;
1401
1402 hole1Cushape->Rmin(1) = dza;
1403 hole1Cushape->Rmax(1) = hole1Cushape->GetRmax(0);
1404 hole1Cushape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
1405 hole1Cushape->GetRmin(1));
1406
1407 hole1Cushape->Rmax(2) = hole1Cushape->GetRmax(0);
1408 hole1Cushape->Rmin(2) = hole1Cushape->GetRmin(1);
1409 hole1Cushape->Z(2) = hole1plastshape->GetZ(3);
1410
1411 hole1Cushape->Rmin(3) = hole1Cushape->GetRmin(1);
1412 hole1Cushape->Rmax(3) = hole1Cushape->GetRmin(3);
1413 hole1Cushape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1414 hole1Cushape->GetRmax(3));
1415
1416 TGeoPcon *hole1glassshape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1417
1418 hole1glassshape->Rmin(0) = hole1Cushape->GetRmin(1);
1419 hole1glassshape->Rmax(0) = hole1glassshape->GetRmin(0);
1420 hole1glassshape->Z(0) = hole1Cushape->GetZ(1);
1421
1422 dza = hole1glassshape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHoleGlassFrac;
1423
1424 hole1glassshape->Rmin(1) = dza;
1425 hole1glassshape->Rmax(1) = hole1glassshape->GetRmax(0);
1426 hole1glassshape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
1427 hole1glassshape->GetRmin(1));
1428
1429 hole1glassshape->Rmax(2) = hole1glassshape->GetRmax(0);
1430 hole1glassshape->Rmin(2) = hole1glassshape->GetRmin(1);
1431 hole1glassshape->Z(2) = hole1Cushape->GetZ(3);
1432
1433 hole1glassshape->Rmin(3) = hole1glassshape->GetRmin(1);
1434 hole1glassshape->Rmax(3) = hole1glassshape->GetRmin(3);
1435 hole1glassshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1436 hole1glassshape->GetRmax(3));
1437 //
1438 TGeoPcon *hole2plastshape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1439
1440 hole2plastshape->Rmin(0) = hole2shape->GetRmin(0);
1441 hole2plastshape->Rmax(0) = hole2shape->GetRmax(0);
1442 hole2plastshape->Z(0) = hole2shape->GetZ(0);
1443
1444 hole2plastshape->Rmin(1) = hole2shape->GetRmin(1);
1445 hole2plastshape->Rmax(1) = hole2shape->GetRmax(1);
1446 hole2plastshape->Z(1) = hole2shape->GetZ(1);
1447
1448 dza = hole2plastshape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHolePlasticFrac;
1449
1450 hole2plastshape->Rmin(2) = dza;
1451 hole2plastshape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
1452 hole2plastshape->GetRmin(2));
1453 hole2plastshape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
1454 hole2plastshape->GetZ(2));
1455
1456 hole2plastshape->Rmin(3) = hole2plastshape->GetRmin(2);
1457 hole2plastshape->Rmax(3) = hole2plastshape->GetRmin(3);
1458 hole2plastshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1459 hole2plastshape->GetRmax(3));
1460
1461 TGeoPcon *hole2Cushape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1462
1463 hole2Cushape->Rmin(0) = hole2plastshape->GetRmin(2);
1464 hole2Cushape->Rmax(0) = hole2Cushape->GetRmin(0);
1465 hole2Cushape->Z(0) = hole2plastshape->GetZ(2);
1466
1467 dza = hole2Cushape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHoleCuFrac;
1468
1469 hole2Cushape->Rmin(1) = dza;
1470 hole2Cushape->Rmax(1) = hole2Cushape->GetRmax(0);
1471 hole2Cushape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
1472 hole2Cushape->GetRmin(1));
1473
1474 hole2Cushape->Rmax(2) = hole2Cushape->GetRmax(0);
1475 hole2Cushape->Rmin(2) = hole2Cushape->GetRmin(1);
1476 hole2Cushape->Z(2) = hole2plastshape->GetZ(3);
1477
1478 hole2Cushape->Rmin(3) = hole2Cushape->GetRmin(1);
1479 hole2Cushape->Rmax(3) = hole2Cushape->GetRmin(3);
1480 hole2Cushape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1481 hole2Cushape->GetRmax(3));
1482
1483 TGeoPcon *hole2glassshape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1484
1485 hole2glassshape->Rmin(0) = hole2Cushape->GetRmin(1);
1486 hole2glassshape->Rmax(0) = hole2glassshape->GetRmin(0);
1487 hole2glassshape->Z(0) = hole2Cushape->GetZ(1);
1488
1489 dza = hole2glassshape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHoleGlassFrac;
1490
1491 hole2glassshape->Rmin(1) = dza;
1492 hole2glassshape->Rmax(1) = hole2glassshape->GetRmax(0);
1493 hole2glassshape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
1494 hole2glassshape->GetRmin(1));
1495
1496 hole2glassshape->Rmax(2) = hole2glassshape->GetRmax(0);
1497 hole2glassshape->Rmin(2) = hole2glassshape->GetRmin(1);
1498 hole2glassshape->Z(2) = hole2Cushape->GetZ(3);
1499
1500 hole2glassshape->Rmin(3) = hole2glassshape->GetRmin(1);
1501 hole2glassshape->Rmax(3) = hole2glassshape->GetRmin(3);
1502 hole2glassshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1503 hole2glassshape->GetRmax(3));
1504
1505
7d6c23de 1506 // Debug if requested
1507 if (GetDebug(1)) {
1508 coneshape->InspectShape();
1509 coneinsertshape->InspectShape();
1510 conefoamshape->InspectShape();
1511 hole1shape->InspectShape();
1512 hole2shape->InspectShape();
a30e33f0 1513 hole3shape->InspectShape();
1514 hole4shape->InspectShape();
7d6c23de 1515 }
1516
1517
1518 // We have the shapes: now create the real volumes
1519
1520 TGeoVolume *cfcone = new TGeoVolume("SDDCarbonFiberCone",
1521 coneshape,medSDDcf);
1522 cfcone->SetVisibility(kTRUE);
1523 cfcone->SetLineColor(4); // Blue
1524 cfcone->SetLineWidth(1);
1525 cfcone->SetFillColor(cfcone->GetLineColor());
1526 cfcone->SetFillStyle(4000); // 0% transparent
1527
1528 TGeoVolume *cfconeinsert = new TGeoVolume("SDDCarbonFiberConeInsert",
1529 coneinsertshape,medSDDste);
1530 cfconeinsert->SetVisibility(kTRUE);
1531 cfconeinsert->SetLineColor(2); // Red
1532 cfconeinsert->SetLineWidth(1);
1533 cfconeinsert->SetFillColor(cfconeinsert->GetLineColor());
1534 cfconeinsert->SetFillStyle(4050); // 50% transparent
1535
1536 TGeoVolume *cfconefoam = new TGeoVolume("SDDCarbonFiberConeFoam",
1537 conefoamshape,medSDDroh);
1538 cfconefoam->SetVisibility(kTRUE);
1539 cfconefoam->SetLineColor(7); // Light blue
1540 cfconefoam->SetLineWidth(1);
1541 cfconefoam->SetFillColor(cfconefoam->GetLineColor());
1542 cfconefoam->SetFillStyle(4050); // 50% transparent
1543
1544 TGeoVolume *hole1 = new TGeoVolume("SDDCableHole1",
1545 hole1shape,medSDDair);
1546 hole1->SetVisibility(kTRUE);
1547 hole1->SetLineColor(5); // Yellow
1548 hole1->SetLineWidth(1);
1549 hole1->SetFillColor(hole1->GetLineColor());
1550 hole1->SetFillStyle(4090); // 90% transparent
1551
a30e33f0 1552 TGeoVolume *hole11 = new TGeoVolume("SDDCableHole11",
1553 hole11shape,medSDDair);
1554 hole11->SetVisibility(kTRUE);
1555 hole11->SetLineColor(5); // Yellow
1556 hole11->SetLineWidth(1);
1557 hole11->SetFillColor(hole11->GetLineColor());
1558 hole11->SetFillStyle(4090); // 90% transparent
1559
1560 TGeoVolume *hole12 = new TGeoVolume("SDDCableHole12",
1561 hole12shape,medSDDair);
1562 hole12->SetVisibility(kTRUE);
1563 hole12->SetLineColor(5); // Yellow
1564 hole12->SetLineWidth(1);
1565 hole12->SetFillColor(hole12->GetLineColor());
1566 hole12->SetFillStyle(4090); // 90% transparent
1567
96eb8210 1568 TGeoVolume *hole1plast = new TGeoVolume("SDDCableHole1Plast",
1569 hole1plastshape,medSDDplast);
1570 hole1plast->SetVisibility(kTRUE);
1571 hole1plast->SetLineColor(kBlue);
1572 hole1plast->SetLineWidth(1);
1573 hole1plast->SetFillColor(hole1plast->GetLineColor());
1574 hole1plast->SetFillStyle(4090); // 90% transparent
1575
1576 TGeoVolume *hole1Cu = new TGeoVolume("SDDCableHole1Cu",
1577 hole1Cushape,medSDDCu);
1578 hole1Cu->SetVisibility(kTRUE);
1579 hole1Cu->SetLineColor(kRed);
1580 hole1Cu->SetLineWidth(1);
1581 hole1Cu->SetFillColor(hole1Cu->GetLineColor());
1582 hole1Cu->SetFillStyle(4090); // 90% transparent
1583
1584 TGeoVolume *hole1glass = new TGeoVolume("SDDCableHole1glass",
1585 hole1glassshape,medSDDglass);
1586 hole1glass->SetVisibility(kTRUE);
1587 hole1glass->SetLineColor(kGreen);
1588 hole1glass->SetLineWidth(1);
1589 hole1glass->SetFillColor(hole1glass->GetLineColor());
1590 hole1glass->SetFillStyle(4090); // 90% transparent
1591
7d6c23de 1592 TGeoVolume *hole2 = new TGeoVolume("SDDCableHole2",
1593 hole2shape,medSDDair);
1594 hole2->SetVisibility(kTRUE);
1595 hole2->SetLineColor(5); // Yellow
1596 hole2->SetLineWidth(1);
1597 hole2->SetFillColor(hole2->GetLineColor());
1598 hole2->SetFillStyle(4090); // 90% transparent
1599
a30e33f0 1600 TGeoVolume *hole21 = new TGeoVolume("SDDCableHole21",
1601 hole21shape,medSDDair);
1602 hole21->SetVisibility(kTRUE);
1603 hole21->SetLineColor(5); // Yellow
1604 hole21->SetLineWidth(1);
1605 hole21->SetFillColor(hole21->GetLineColor());
1606 hole21->SetFillStyle(4090); // 90% transparent
1607
1608 TGeoVolume *hole22 = new TGeoVolume("SDDCableHole22",
1609 hole22shape,medSDDair);
1610 hole22->SetVisibility(kTRUE);
1611 hole22->SetLineColor(5); // Yellow
1612 hole22->SetLineWidth(1);
1613 hole22->SetFillColor(hole22->GetLineColor());
1614 hole22->SetFillStyle(4090); // 90% transparent
1615
96eb8210 1616 TGeoVolume *hole2plast = new TGeoVolume("SDDCableHole2Plast",
1617 hole2plastshape,medSDDplast);
1618 hole2plast->SetVisibility(kTRUE);
1619 hole2plast->SetLineColor(kBlue);
1620 hole2plast->SetLineWidth(1);
1621 hole2plast->SetFillColor(hole2plast->GetLineColor());
1622 hole2plast->SetFillStyle(4090); // 90% transparent
1623
1624 TGeoVolume *hole2Cu = new TGeoVolume("SDDCableHole2Cu",
1625 hole2Cushape,medSDDCu);
1626 hole2Cu->SetVisibility(kTRUE);
1627 hole2Cu->SetLineColor(kRed);
1628 hole2Cu->SetLineWidth(1);
1629 hole2Cu->SetFillColor(hole2Cu->GetLineColor());
1630 hole2Cu->SetFillStyle(4090); // 90% transparent
1631
1632 TGeoVolume *hole2glass = new TGeoVolume("SDDCableHole2glass",
1633 hole2glassshape,medSDDglass);
1634 hole2glass->SetVisibility(kTRUE);
1635 hole2glass->SetLineColor(kGreen);
1636 hole2glass->SetLineWidth(1);
1637 hole2glass->SetFillColor(hole2glass->GetLineColor());
1638 hole2glass->SetFillStyle(4090); // 90% transparent
1639
7d6c23de 1640 TGeoVolume *hole3 = new TGeoVolume("SDDCableHole3",
1641 hole3shape,medSDDair);
1642 hole3->SetVisibility(kTRUE);
1643 hole3->SetLineColor(5); // Yellow
1644 hole3->SetLineWidth(1);
1645 hole3->SetFillColor(hole3->GetLineColor());
1646 hole3->SetFillStyle(4090); // 90% transparent
1647
a30e33f0 1648 TGeoVolume *hole31 = new TGeoVolume("SDDCableHole31",
1649 hole31shape,medSDDair);
1650 hole31->SetVisibility(kTRUE);
1651 hole31->SetLineColor(5); // Yellow
1652 hole31->SetLineWidth(1);
1653 hole31->SetFillColor(hole31->GetLineColor());
1654 hole31->SetFillStyle(4090); // 90% transparent
1655
1656 TGeoVolume *hole32 = new TGeoVolume("SDDCableHole32",
1657 hole32shape,medSDDair);
1658 hole32->SetVisibility(kTRUE);
1659 hole32->SetLineColor(5); // Yellow
1660 hole32->SetLineWidth(1);
1661 hole32->SetFillColor(hole32->GetLineColor());
1662 hole32->SetFillStyle(4090); // 90% transparent
1663
7d6c23de 1664 TGeoVolume *hole4 = new TGeoVolume("SDDCableHole4",
1665 hole4shape,medSDDair);
1666 hole4->SetVisibility(kTRUE);
1667 hole4->SetLineColor(5); // Yellow
1668 hole4->SetLineWidth(1);
1669 hole4->SetFillColor(hole4->GetLineColor());
1670 hole4->SetFillStyle(4090); // 90% transparent
1671
1672 // Mount up a cone
1673 cfconeinsert->AddNode(cfconefoam,1,0);
1674
96eb8210 1675 hole1->AddNode(hole1plast, 1, 0);
1676 hole1->AddNode(hole1Cu, 1, 0);
1677 hole1->AddNode(hole1glass, 1, 0);
1678
1679 hole2->AddNode(hole2plast, 1, 0);
1680 hole2->AddNode(hole2Cu, 1, 0);
1681 hole2->AddNode(hole2glass, 1, 0);
1682
7d6c23de 1683 for (Int_t i=0; i<12; i++) {
1684 Double_t phiH = i*30.0;
a30e33f0 1685 cfconefoam->AddNode(hole1 , i+1, new TGeoRotation("", 0, 0, phiH));
1686 cfcone->AddNode(hole11, i+1, new TGeoRotation("", 0, 0, phiH));
1687 cfcone->AddNode(hole12, i+1, new TGeoRotation("", 0, 0, phiH));
7d6c23de 1688 }
1689
1690 for (Int_t i=0; i<6; i++) {
1691 Double_t phiH = i*60.0;
a30e33f0 1692 cfconefoam->AddNode(hole2 , i+1, new TGeoRotation("", 0, 0, phiH));
1693 cfcone->AddNode(hole21, i+1, new TGeoRotation("", 0, 0, phiH));
1694 cfcone->AddNode(hole22, i+1, new TGeoRotation("", 0, 0, phiH));
7d6c23de 1695 }
1696
1697 for (Int_t i=0; i<kNHole3; i++) {
1698 Double_t phiH0 = 360./(Double_t)kNHole3;
1699 Double_t phiH = i*phiH0 + 0.5*phiH0;
a30e33f0 1700 cfconefoam->AddNode(hole3 , i+1, new TGeoRotation("", phiH, 0, 0));
1701 cfcone->AddNode(hole31, i+1, new TGeoRotation("", phiH, 0, 0));
1702 cfcone->AddNode(hole32, i+1, new TGeoRotation("", phiH, 0, 0));
7d6c23de 1703 }
a30e33f0 1704
1705 cfcone->AddNode(cfconeinsert,1,0);
1706
7d6c23de 1707/*
1708 for (Int_t i=0; i<kNHole4; i++) {
1709 Double_t phiH0 = 360./(Double_t)kNHole4;
1710 Double_t phiH = i*phiH0 + 0.25*phiH0;
1711 cfcone->AddNode(hole4, i+1, new TGeoRotation("", phiH, 0, 0));
1712 }
1713*/
3a299c65 1714 // Finally put everything in the mother volume
1715 moth->AddNode(cfcylinder,1,0);
7d6c23de 1716
1717 z = coneshape->Z(9);
3a299c65 1718 moth->AddNode(cfcone,1,new TGeoTranslation(0, 0, -z - kCylinderHalfLength));
1719 moth->AddNode(cfcone,2,new TGeoCombiTrans (0, 0, z + kCylinderHalfLength,
1720 new TGeoRotation("", 0, 180, 0) ));
7d6c23de 1721
7d6c23de 1722
1723 return;
172b0d90 1724}
7d6c23de 1725
172b0d90 1726//______________________________________________________________________
3a299c65 1727void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,TGeoManager *mgr)
1728{
1729//
1730// Creates the SSD support cone and cylinder geometry. as a
1731// volume assembly and adds it to the mother volume
1732// (part of this code is taken or anyway inspired to SSDCone method
1733// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
1734//
1735// Input:
1736// moth : the TGeoVolume owing the volume structure
1737// mgr : the GeoManager (default gGeoManager)
1738// Output:
1739//
1740// Created: ??? Bjorn S. Nilsen
1741// Updated: 08 Mar 2008 Mario Sitta
1742//
1743// Technical data are taken from: "ITS Supporto Generale" (technical
1744// drawings ALR3-0743/1, ALR3-0743/1A and ALR3-0743/1B), "Supporto Generale
1745// Settore SSD" (technical drawings ALR3-0743/2A and ALR3-0743/2E), private
1746// communication with B. Giraudo
5e15508a 1747//
1748// Updated: 11 Apr 2008 Mario Sitta
1749// Measures from drawings give overlaps with SPD thermal shield wings,
1750// so the terminal part of the SSD cone was reduced
573a206f 1751//
1752// Updated: 30 Mar 2010 Mario Sitta
1753// Following M. van Leeuwen's suggestion on material budget, the thickness
1754// of the carbon fiber cylinder was increased from 0.6 to 0.625mm
3a299c65 1755
1756 // Dimensions of the Central cylinder and flanges
1757 const Double_t kCylinderHalfLength = (1144.0/2) *fgkmm;
1758 const Double_t kCylinderOuterRadius = ( 595.0/2) *fgkmm;
573a206f 1759 const Double_t kCylinderThickness = 0.625*fgkmm;
3a299c65 1760 const Double_t kFoamHalfLength = (1020.0/2) *fgkmm;
1761 const Double_t kFoamThickness = 5.0 *fgkmm;
1762 const Double_t kFlangeHalfLength =
1763 (kCylinderHalfLength-kFoamHalfLength)/2.;
1764 const Double_t kFlangeInnerRadius = ( 563.0/2) *fgkmm;
1765 // Dimensions of the Cone
fd5b6398 1766 const Double_t kConeROuterMin = ( 957.0/2) *fgkmm;
1767 const Double_t kConeROuterMax = ( 997.0/2) *fgkmm;
3a299c65 1768 const Double_t kConeRInnerMin = ( 564.0/2) *fgkmm;
1769 const Double_t kConeRCurv1 = 10.0 *fgkmm;
1770 const Double_t kConeRCurv2 = 25.0 *fgkmm;
1771 const Double_t kConeCent1RCurv2 = ( 578.0/2) *fgkmm;
6b42825b 1772 const Double_t kConeCent2RCurv2 = ( 592.0/2) *fgkmm;
5e15508a 1773// const Double_t kConeZOuterRing = 47.0 *fgkmm;
1774// const Double_t kConeZOuterRingInside = 30.25*fgkmm;
1775// const Double_t kConeZInnerRing = 161.5 *fgkmm;
1776// const Double_t kConeZLength = 176.5 *fgkmm;
1777 const Double_t kConeZOuterRing = 38.5 *fgkmm;
1778 const Double_t kConeZOuterRingInside = 22.2 *fgkmm;
1779 const Double_t kConeZInnerRing = 153.0 *fgkmm;
1780 const Double_t kConeZLength = 168.0 *fgkmm;
3a299c65 1781 const Double_t kConeZPosition = kConeZLength + kCylinderHalfLength;
1782 const Double_t kConeThickness = 13.0 *fgkmm; // Cone thickness
81adc4e0 1783 const Double_t kConeTheta = 39.1 *fgkDegree; // Cone angle
3a299c65 1784 const Double_t kSinConeTheta =
1785 TMath::Sin(kConeTheta*TMath::DegToRad());
1786 const Double_t kCosConeTheta =
1787 TMath::Cos(kConeTheta*TMath::DegToRad());
1788 // Dimensions of the Foam cores
1789 const Double_t kConeFoam1Length = 112.3 *fgkmm;
1790 const Double_t kConeFoam2Length = 58.4 *fgkmm;
1791 // Dimensions of the Cone Holes
1792 const Double_t kCoolingHoleWidth = 40.0 *fgkmm;
1793 const Double_t kCoolingHoleHight = 30.0 *fgkmm;
1794 const Double_t kCoolingHoleRmin = 350.0 *fgkmm;
1795 const Double_t kCoolingHolePhi = 45.0 *fgkDegree;
1796 const Double_t kMountingHoleWidth = 20.0 *fgkmm;
1797 const Double_t kMountingHoleHight = 20.0 *fgkmm;
1798 const Double_t kMountingHoleRmin = 317.5 *fgkmm;
1799 const Double_t kMountingHolePhi = 60.0 *fgkDegree;
1800 const Double_t kCableHoleRin = ( 800.0/2) *fgkmm;
1801 const Double_t kCableHoleRout = ( 920.0/2) *fgkmm;
1802 const Double_t kCableHoleWidth = 200.0 *fgkmm;
1803// const Double_t kCableHoleAngle = 42.0 *fgkDegree;
1804 // Dimensions of the Cone Wings
1805 const Double_t kWingRmax = 527.5 *fgkmm;
1806 const Double_t kWingWidth = 70.0 *fgkmm;
1807 const Double_t kWingHalfThick = ( 10.0/2) *fgkmm;
1808 const Double_t kThetaWing = 45.0 *fgkDegree;
1809 // Dimensions of the SSD-SDD Mounting Brackets
989ee428 1810 const Double_t kBracketRmin = ( 541.0/2) *fgkmm;// See SDD ROutMin
3a299c65 1811 const Double_t kBracketRmax = ( 585.0/2) *fgkmm;
1812 const Double_t kBracketHalfLength = ( 4.0/2) *fgkmm;
1813 const Double_t kBracketPhi = (70.*fgkmm/kBracketRmax)*fgkRadian;
1814 // Common data
1815 const Double_t kCFThickness = 0.75*fgkmm; //Carb. fib. thick.
1816
1817
1818 // Local variables
1819 Double_t rmin1, rmin2, rmax, z;
1820
1821 //
1822 //Begin_Html
1823 /*
1824 <img src="picts/ITS/file_name.gif">
1825 <P>
1826 <FONT FACE'"TIMES">
1827 ITS SSD central support and thermal shield cylinder.
1828 </FONT>
1829 </P>
1830 */
1831 //End_Html
1832 //
1833
1834 // Central cylinder with its internal foam and the lateral flanges:
1835 // a carbon fiber Pcon which contains a rohacell Tube and two
1836 // stesalite Cone's
1837 TGeoPcon *externalcylshape = new TGeoPcon(0,360,4);
1838
1839 rmax = kCylinderOuterRadius;
1840 rmin1 = kFlangeInnerRadius - kCylinderThickness;
1841 rmin2 = rmax - 2*kCylinderThickness - kFoamThickness;
1842 externalcylshape->DefineSection(0,-kCylinderHalfLength,rmin1,rmax);
1843 externalcylshape->DefineSection(1,-kFoamHalfLength ,rmin2,rmax);
1844 externalcylshape->DefineSection(2, kFoamHalfLength ,rmin2,rmax);
1845 externalcylshape->DefineSection(3, kCylinderHalfLength,rmin1,rmax);
1846
1847 rmax = kCylinderOuterRadius - kCylinderThickness;
1848 rmin1 = rmax - kFoamThickness;
1849 TGeoTube *foamshape = new TGeoTube(rmin1,rmax,kFoamHalfLength);
1850
1851 rmax = kCylinderOuterRadius - kCylinderThickness;
1852 rmin1 = rmax - kFoamThickness;
1853 rmin2 = kFlangeInnerRadius;
1854 TGeoCone *flangeshape = new TGeoCone(kFlangeHalfLength,
1855 rmin1,rmax,rmin2,rmax);
1856
1857
1858 // We have the shapes: now create the real volumes
1859
1860 TGeoMedium *medSSDcf = mgr->GetMedium("ITS_SSD C (M55J)$");
1861 TGeoMedium *medSSDair = mgr->GetMedium("ITS_SSD AIR$");
1862 TGeoMedium *medSSDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
1863 TGeoMedium *medSSDroh = mgr->GetMedium("ITS_ROHACELL$");
1864 TGeoMedium *medSSDal = mgr->GetMedium("ITS_ALUMINUM$");
1865
1866 TGeoVolume *cfcylinder = new TGeoVolume("SSDexternalcylinder",
1867 externalcylshape,medSSDcf);
1868 cfcylinder->SetVisibility(kTRUE);
1869 cfcylinder->SetLineColor(4); // blue
1870 cfcylinder->SetLineWidth(1);
1871 cfcylinder->SetFillColor(cfcylinder->GetLineColor());
1872 cfcylinder->SetFillStyle(4000); // 0% transparent
1873
1874 TGeoVolume *foamcylinder = new TGeoVolume("SSDfoamcylinder",
1875 foamshape,medSSDroh);
1876 foamcylinder->SetVisibility(kTRUE);
1877 foamcylinder->SetLineColor(3); // green
1878 foamcylinder->SetLineWidth(1);
1879 foamcylinder->SetFillColor(foamcylinder->GetLineColor());
1880 foamcylinder->SetFillStyle(4050); // 50% transparent
1881
1882 TGeoVolume *flangecylinder = new TGeoVolume("SSDflangecylinder",
1883 flangeshape,medSSDste);
1884 flangecylinder->SetVisibility(kTRUE);
1885 flangecylinder->SetLineColor(2); // red
1886 flangecylinder->SetLineWidth(1);
1887 flangecylinder->SetFillColor(flangecylinder->GetLineColor());
1888 flangecylinder->SetFillStyle(4050); // 50% transparent
1889
1890 // Mount up the cylinder
1891 cfcylinder->AddNode(foamcylinder,1,0);
1892 cfcylinder->AddNode(flangecylinder,1,
1893 new TGeoTranslation(0, 0, kFoamHalfLength+kFlangeHalfLength));
1894 cfcylinder->AddNode(flangecylinder,2,new TGeoCombiTrans(
1895 0, 0, -kFoamHalfLength-kFlangeHalfLength,
1896 new TGeoRotation("",0,180,0) ) );
1897
1898
1899 // The whole Cone as an assembly
1900 TGeoVolumeAssembly *vC = new TGeoVolumeAssembly("ITSssdCone");
1901
1902
1903 // SSD Support Cone with its internal inserts: a carbon fiber Pcon
1904 // with holes which contains a stesalite Pcon which on turn contains a
1905 // rohacell Pcon
1906 TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 12);
1907
1908 coneshape->Z(0) = 0.0;
1909 coneshape->Rmin(0) = kConeROuterMin;
1910 coneshape->Rmax(0) = kConeROuterMax;
1911
1912 coneshape->Z(1) = kConeZOuterRingInside - kConeRCurv1;
1913 coneshape->Rmin(1) = coneshape->GetRmin(0);
1914 coneshape->Rmax(1) = coneshape->GetRmax(0);
1915
1916 coneshape->Z(2) = kConeZOuterRingInside;
1917 coneshape->Rmin(2) = coneshape->GetRmin(1) - kConeRCurv1;
1918 coneshape->Rmax(2) = coneshape->GetRmax(0);
1919
1920 coneshape->Z(3) = coneshape->GetZ(2);
1921 coneshape->Rmax(3) = coneshape->GetRmax(0);
1922
1923 coneshape->Z(4) = kConeZOuterRing - kConeRCurv1;
1924 coneshape->Rmax(4) = coneshape->GetRmax(0);
1925
1926 coneshape->Z(5) = kConeZOuterRing;
1927 coneshape->Rmax(5) = coneshape->GetRmax(4) - kConeRCurv1;
1928
1929 coneshape->Z(6) = coneshape->GetZ(5);
1930
1931 RadiusOfCurvature(kConeRCurv2,90.0,kConeZInnerRing,kConeCent1RCurv2,
1932 90.0-kConeTheta,z,rmin1);
1933 coneshape->Z(7) = z;
1934 coneshape->Rmin(7) = rmin1;
1935
1936 coneshape->Rmin(3) = RminFromZpCone(coneshape,7,90.-kConeTheta,
1937 coneshape->GetZ(3));
1938
1939 coneshape->Rmin(4) = RminFrom2Points(coneshape,3,7,coneshape->GetZ(4));
1940
1941 coneshape->Rmin(5) = RminFrom2Points(coneshape,3,7,coneshape->GetZ(5));
1942
1943 coneshape->Rmin(6) = coneshape->GetRmin(5);
1944
1945 coneshape->Z(8) = kConeZInnerRing;
1946 coneshape->Rmin(8) = kConeCent1RCurv2;
1947
1948 coneshape->Z(9) = coneshape->GetZ(8);
1949 coneshape->Rmin(9) = kConeRInnerMin;
1950
1951 RadiusOfCurvature(kConeRCurv2,90.0,kConeZLength,kConeCent2RCurv2,
1952 90.0-kConeTheta,z,rmax);
1953
1954 coneshape->Z(10) = z;
1955 coneshape->Rmin(10) = coneshape->GetRmin(9);
1956 coneshape->Rmax(10) = rmax;
1957
1958 coneshape->Rmax(6) = RmaxFromZpCone(coneshape,10,90.-kConeTheta,
1959 coneshape->GetZ(6));
1960
1961 coneshape->Rmax(7) = RmaxFrom2Points(coneshape,6,10,coneshape->GetZ(7));
1962
1963 coneshape->Rmax(8) = RmaxFrom2Points(coneshape,6,10,coneshape->GetZ(8));
1964
1965 coneshape->Rmax(9) = coneshape->GetRmax(8);
1966
1967 coneshape->Z(11) = kConeZLength;
1968 coneshape->Rmin(11) = coneshape->GetRmin(10);
1969 coneshape->Rmax(11) = kConeCent2RCurv2;
1970
1971 // SSD Cone Insert: another Pcon
1972 Double_t x0, y0, x1, y1, x2, y2;
1973 TGeoPcon *coneinsertshape = new TGeoPcon(0.0,360.0,12);
1974
1975 coneinsertshape->Z(0) = coneshape->GetZ(0) + kCFThickness;
1976 coneinsertshape->Rmin(0) = coneshape->GetRmin(0) + kCFThickness;
1977 coneinsertshape->Rmax(0) = coneshape->GetRmax(0) - kCFThickness;
1978
1979 x0 = coneshape->GetZ(0); y0 = coneshape->GetRmin(0);
1980 x1 = coneshape->GetZ(1); y1 = coneshape->GetRmin(1);
1981 x2 = coneshape->GetZ(2); y2 = coneshape->GetRmin(2);
1982 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
1983 coneinsertshape->Z(1) = z;
1984 coneinsertshape->Rmin(1) = rmin1;
1985 coneinsertshape->Rmax(1) = coneinsertshape->GetRmax(0);
1986
1987 x0 = coneshape->GetZ(1); y0 = coneshape->GetRmin(1);
1988 x1 = coneshape->GetZ(2); y1 = coneshape->GetRmin(2);
1989 x2 = coneshape->GetZ(3); y2 = coneshape->GetRmin(3);
1990 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
1991 coneinsertshape->Z(2) = z;
1992 coneinsertshape->Rmin(2) = rmin1;
1993 coneinsertshape->Rmax(2) = coneinsertshape->GetRmax(1);
1994
1995 x0 = coneshape->GetZ(2); y0 = coneshape->GetRmin(2);
1996 x1 = coneshape->GetZ(3); y1 = coneshape->GetRmin(3);
1997 x2 = coneshape->GetZ(4); y2 = coneshape->GetRmin(4);
1998 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
1999 coneinsertshape->Z(3) = z;
2000 coneinsertshape->Rmin(3) = rmin1;
2001 coneinsertshape->Rmax(3) = coneinsertshape->GetRmax(2);
2002
2003 x0 = coneshape->GetZ(3); y0 = coneshape->GetRmax(3);
2004 x1 = coneshape->GetZ(4); y1 = coneshape->GetRmax(4);
2005 x2 = coneshape->GetZ(5); y2 = coneshape->GetRmax(5);
2006 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2007 coneinsertshape->Z(4) = z;
2008 coneinsertshape->Rmax(4) = rmax;
2009
2010 x0 = coneshape->GetZ(4); y0 = coneshape->GetRmax(4);
2011 x1 = coneshape->GetZ(5); y1 = coneshape->GetRmax(5);
2012 x2 = coneshape->GetZ(6); y2 = coneshape->GetRmax(6);
2013 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2014 coneinsertshape->Z(5) = z;
2015 coneinsertshape->Rmax(5) = rmax;
2016
2017 x0 = coneshape->GetZ(5); y0 = coneshape->GetRmax(5);
2018 x1 = coneshape->GetZ(6); y1 = coneshape->GetRmax(6);
2019 x2 = coneshape->GetZ(7); y2 = coneshape->GetRmax(7);
2020 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2021 coneinsertshape->Z(6) = z;
2022 coneinsertshape->Rmax(6) = rmax;
2023
2024 x0 = coneshape->GetZ(6); y0 = coneshape->GetRmin(6);
2025 x1 = coneshape->GetZ(7); y1 = coneshape->GetRmin(7);
2026 x2 = coneshape->GetZ(8); y2 = coneshape->GetRmin(8);
2027 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2028 coneinsertshape->Z(7) = z;
2029 coneinsertshape->Rmin(7) = rmin1;
2030
2031 coneinsertshape->Rmin(4) = RminFrom2Points(coneinsertshape,3,7,
2032 coneinsertshape->GetZ(4));
2033
2034 coneinsertshape->Rmin(5) = RminFrom2Points(coneinsertshape,3,7,
2035 coneinsertshape->GetZ(5));
2036
2037 coneinsertshape->Rmin(6) = coneinsertshape->GetRmin(5);
2038
2039 x0 = coneshape->GetZ(7); y0 = coneshape->GetRmin(7);
2040 x1 = coneshape->GetZ(8); y1 = coneshape->GetRmin(8);
2041 x2 = coneshape->GetZ(9); y2 = coneshape->GetRmin(9);
2042 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2043 coneinsertshape->Z(8) = z;
2044 coneinsertshape->Rmin(8) = rmin1;
2045
2046 x0 = coneshape->GetZ( 8); y0 = coneshape->GetRmin( 8);
2047 x1 = coneshape->GetZ( 9); y1 = coneshape->GetRmin( 9);
2048 x2 = coneshape->GetZ(10); y2 = coneshape->GetRmin(10);
2049 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2050 coneinsertshape->Z(9) = z;
2051 coneinsertshape->Rmin(9) = rmin1;
2052
2053 x0 = coneshape->GetZ( 9); y0 = coneshape->GetRmax( 9);
2054 x1 = coneshape->GetZ(10); y1 = coneshape->GetRmax(10);
2055 x2 = coneshape->GetZ(11); y2 = coneshape->GetRmax(11);
2056 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2057 coneinsertshape->Z(10) = z;
2058 coneinsertshape->Rmax(10) = rmax;
2059 coneinsertshape->Rmin(10) = coneinsertshape->GetRmin(9);
2060
2061 coneinsertshape->Rmax(7) = RmaxFrom2Points(coneinsertshape,6,10,
2062 coneinsertshape->GetZ(7));
2063
2064 coneinsertshape->Rmax(8) = RmaxFrom2Points(coneinsertshape,6,10,
2065 coneinsertshape->GetZ(8));
2066
2067 coneinsertshape->Rmax(9) = coneinsertshape->GetRmax(8);
2068
2069 x0 = coneshape->GetZ(10); y0 = coneshape->GetRmax(10);
2070 x1 = coneshape->GetZ(11); y1 = coneshape->GetRmax(11);
2071 x2 = coneshape->GetZ(11); y2 = coneshape->GetRmin(11);
2072 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2073 coneinsertshape->Z(11) = z;
2074 coneinsertshape->Rmax(11) = rmax;
2075 coneinsertshape->Rmin(11) = coneinsertshape->GetRmin(10);
2076
2077 // SSD Cone Foams: two other Pcon's
2078 TGeoPcon *conefoam1shape = new TGeoPcon(0.0, 360.0, 4);
2079
2080 conefoam1shape->Z(0) = coneinsertshape->GetZ(3);
2081 conefoam1shape->Rmin(0) = coneinsertshape->GetRmin(3);
2082 conefoam1shape->Rmax(0) = conefoam1shape->GetRmin(0);
2083
2084 conefoam1shape->Rmax(1) = conefoam1shape->GetRmax(0);
2085 conefoam1shape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2086 conefoam1shape->GetRmax(1));
2087 conefoam1shape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2088 conefoam1shape->GetZ(1));
2089
2090 Double_t t = kConeThickness - 2*kCFThickness;
2091 conefoam1shape->Rmin(2) = conefoam1shape->GetRmax(0) -
2092 (kConeFoam1Length*kCosConeTheta - t*kSinConeTheta);
2093 conefoam1shape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2094 conefoam1shape->GetRmin(2));
2095 conefoam1shape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2096 conefoam1shape->GetZ(2));
2097
2098 conefoam1shape->Rmin(3) = conefoam1shape->GetRmin(2);
2099 conefoam1shape->Rmax(3) = conefoam1shape->GetRmin(3);
2100 conefoam1shape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2101 conefoam1shape->GetRmax(3));
2102
2103 TGeoPcon *conefoam2shape = new TGeoPcon(0.0, 360.0, 4);
2104
2105 conefoam2shape->Z(3) = coneinsertshape->GetZ(10);
2106 conefoam2shape->Rmin(3) = coneinsertshape->GetRmax(10);
2107 conefoam2shape->Rmax(3) = conefoam2shape->GetRmin(3);
2108
2109 conefoam2shape->Rmin(2) = conefoam2shape->GetRmin(3);
2110 conefoam2shape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2111 conefoam2shape->GetRmin(2));
2112 conefoam2shape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2113 conefoam2shape->GetZ(2));
2114
2115 conefoam2shape->Rmin(0) = conefoam2shape->GetRmax(2) +
2116 (kConeFoam2Length*kCosConeTheta - t*kSinConeTheta);
2117 conefoam2shape->Rmax(0) = conefoam2shape->GetRmin(0);
2118 conefoam2shape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2119 conefoam2shape->GetRmin(0));
2120
2121 conefoam2shape->Rmax(1) = conefoam2shape->GetRmax(0);
2122 conefoam2shape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2123 conefoam2shape->GetRmax(1));
2124 conefoam2shape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2125 conefoam2shape->GetZ(1));
2126
2127 // SSD Cone Holes: Pcon's
a30e33f0 2128 // A single hole volume gives an overlap with coneinsert, so
2129 // three contiguous volumes are created: one to be put in coneinsert
2130 // and two in the cone carbon fiber envelope
3a299c65 2131 Double_t holePhi;
2132 holePhi = (kCoolingHoleWidth/kCoolingHoleRmin)*TMath::RadToDeg();
2133
2134 TGeoPcon *coolingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4);
2135
2136 coolingholeshape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
2137 coolingholeshape->Rmax(0) = coolingholeshape->GetRmin(0);
a30e33f0 2138 coolingholeshape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
3a299c65 2139 coolingholeshape->GetRmin(0));
2140
2141 coolingholeshape->Rmax(1) = coolingholeshape->GetRmax(0);
a30e33f0 2142 coolingholeshape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
3a299c65 2143 coolingholeshape->GetRmax(1));
a30e33f0 2144 coolingholeshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
3a299c65 2145 coolingholeshape->GetZ(1));
2146
2147 coolingholeshape->Rmin(2) = kCoolingHoleRmin;
a30e33f0 2148 coolingholeshape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
3a299c65 2149 coolingholeshape->GetRmin(2));
a30e33f0 2150 coolingholeshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
3a299c65 2151 coolingholeshape->GetZ(2));
2152
2153 coolingholeshape->Rmin(3) = coolingholeshape->GetRmin(2);
2154 coolingholeshape->Rmax(3) = coolingholeshape->GetRmin(3);
a30e33f0 2155 coolingholeshape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
3a299c65 2156 coolingholeshape->GetRmax(3));
2157
a30e33f0 2158 TGeoPcon *coolinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2159
2160 coolinghole2shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
2161 coolinghole2shape->Rmax(0) = coolinghole2shape->GetRmin(0);
2162 coolinghole2shape->Z(0) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2163 coolinghole2shape->GetRmin(0));
2164
2165 coolinghole2shape->Rmax(1) = coolinghole2shape->GetRmax(0);
2166 coolinghole2shape->Z(1) = coolingholeshape->GetZ(0);
2167 coolinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
2168 coolinghole2shape->GetZ(1));
2169
2170 coolinghole2shape->Rmin(2) = kCoolingHoleRmin;
2171 coolinghole2shape->Z(2) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2172 coolinghole2shape->GetRmin(2));
2173 coolinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2174 coolinghole2shape->GetZ(2));
2175
2176 coolinghole2shape->Rmin(3) = coolinghole2shape->GetRmin(2);
2177 coolinghole2shape->Rmax(3) = coolinghole2shape->GetRmin(3);
2178 coolinghole2shape->Z(3) = coolingholeshape->GetZ(2);
2179
2180 TGeoPcon *coolinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2181
2182 coolinghole3shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
2183 coolinghole3shape->Rmax(0) = coolinghole3shape->GetRmin(0);
2184 coolinghole3shape->Z(0) = coolingholeshape->GetZ(1);
2185
2186 coolinghole3shape->Rmax(1) = coolinghole3shape->GetRmax(0);
2187 coolinghole3shape->Z(1) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2188 coolinghole3shape->GetRmax(1));
2189 coolinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2190 coolinghole3shape->GetZ(1));
2191
2192 coolinghole3shape->Rmin(2) = kCoolingHoleRmin;
2193 coolinghole3shape->Z(2) = coolingholeshape->GetZ(3);
2194 coolinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
2195 coolinghole3shape->GetZ(2));
2196
2197 coolinghole3shape->Rmin(3) = coolinghole3shape->GetRmin(2);
2198 coolinghole3shape->Rmax(3) = coolinghole3shape->GetRmin(3);
2199 coolinghole3shape->Z(3) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2200 coolinghole3shape->GetRmax(3));
2201
2202 //
3a299c65 2203 holePhi = (kMountingHoleWidth/kMountingHoleRmin)*TMath::RadToDeg();
2204
2205 TGeoPcon *mountingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4);
2206
2207 mountingholeshape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
2208 mountingholeshape->Rmax(0) = mountingholeshape->GetRmin(0);
2209 mountingholeshape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2210 mountingholeshape->GetRmin(0));
2211
2212 mountingholeshape->Rmin(1) = kMountingHoleRmin;
2213 mountingholeshape->Rmax(1) = mountingholeshape->GetRmax(0);
2214 mountingholeshape->Z(1) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2215 mountingholeshape->GetRmin(1));
2216
2217 mountingholeshape->Rmin(2) = mountingholeshape->GetRmin(1);
2218 mountingholeshape->Rmax(2) = mountingholeshape->GetRmax(1);
2219 mountingholeshape->Z(2) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2220 mountingholeshape->GetRmax(2));
2221
2222 mountingholeshape->Rmin(3) = mountingholeshape->GetRmin(2);
2223 mountingholeshape->Rmax(3) = mountingholeshape->GetRmin(3);
2224 mountingholeshape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2225 mountingholeshape->GetRmax(3));
2226
2227 TGeoPcon *mountinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2228
2229 mountinghole2shape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
2230 mountinghole2shape->Rmax(0) = mountingholeshape->GetRmin(0);
2231 mountinghole2shape->Z(0) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2232 mountinghole2shape->GetRmin(0));
2233
2234 mountinghole2shape->Rmax(1) = mountinghole2shape->GetRmax(0);
2235 mountinghole2shape->Z(1) = mountingholeshape->Z(0);
2236 mountinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
2237 mountinghole2shape->GetZ(1));
2238
2239 mountinghole2shape->Rmin(2) = kMountingHoleRmin;
2240 mountinghole2shape->Z(2) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2241 mountinghole2shape->GetRmin(2));
2242 mountinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2243 mountinghole2shape->GetZ(2));
2244
2245 mountinghole2shape->Rmin(3) = mountinghole2shape->Rmin(2);
2246 mountinghole2shape->Rmax(3) = mountinghole2shape->Rmin(3);
2247 mountinghole2shape->Z(3) = mountingholeshape->Z(1);
2248
2249 TGeoPcon *mountinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2250
2251 mountinghole3shape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
2252 mountinghole3shape->Rmax(0) = mountingholeshape->GetRmin(0);
2253 mountinghole3shape->Z(0) = mountingholeshape->GetZ(2);
2254
2255 mountinghole3shape->Rmax(1) = mountinghole3shape->GetRmax(0);
2256 mountinghole3shape->Z(1) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2257 mountinghole3shape->GetRmax(1));
2258 mountinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2259 mountinghole3shape->GetZ(1));
2260
2261 mountinghole3shape->Rmin(2) = kMountingHoleRmin;
2262 mountinghole3shape->Z(2) = mountingholeshape->Z(3);
2263 mountinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
2264 mountinghole3shape->GetZ(2));
2265
2266 mountinghole3shape->Rmin(3) = mountinghole3shape->Rmin(2);
2267 mountinghole3shape->Rmax(3) = mountinghole3shape->Rmin(3);
2268 mountinghole3shape->Z(3) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2269 mountinghole3shape->GetRmax(3));
2270
2271 // The Cable Hole is even more complicated, a Composite Shape
2272 // is unavoidable here (gosh!)
2273 TGeoPcon *coneshapecopy = new TGeoPcon("conecopy",0.0, 360.0, 12);
2274
2275 for (Int_t i=0; i<12; i++) {
2276 coneshapecopy->Rmin(i) = coneshape->GetRmin(i);
2277 coneshapecopy->Rmax(i) = coneshape->GetRmax(i);
2278 coneshapecopy->Z(i) = coneshape->GetZ(i);
2279 }
2280
2281 holePhi = (kCableHoleWidth/kCableHoleRout)*TMath::RadToDeg();
2282 TGeoConeSeg *chCS = new TGeoConeSeg("chCS", 0.5*kConeZLength,
2283 kCableHoleRin, kCableHoleRout,
2284 kCableHoleRin, kCableHoleRout,
2285 -0.5*holePhi, 0.5*holePhi);
2286
2287 TGeoCompositeShape *cableholeshape = new TGeoCompositeShape(
2288 "SSDCableHoleShape",
2289 "conecopy*chCS");
2290
2291 if(GetDebug(1)){
2292 chCS->InspectShape();
2293 cableholeshape->InspectShape();
2294 }
2295
2296 // SSD Cone Wings: Tube and TubeSeg shapes
2297 Double_t angleWideWing, angleWideWingThickness;
2298 angleWideWing = (kWingWidth/kWingRmax)*TMath::RadToDeg();
2299 angleWideWingThickness = (kCFThickness/kWingRmax)*TMath::RadToDeg();
2300
2301 TGeoTubeSeg *wingshape = new TGeoTubeSeg(kConeROuterMax, kWingRmax,
2302 kWingHalfThick,
2303 0, angleWideWing);
2304
2305 TGeoTubeSeg *winginsertshape = new TGeoTubeSeg(kConeROuterMax,
2306 kWingRmax-kCFThickness,
2307 kWingHalfThick-kCFThickness,
2308 angleWideWingThickness,
2309 angleWideWing-angleWideWingThickness);
2310
2311 // SDD support plate, SSD side (Mounting Bracket): a TubeSeg
2312 TGeoTubeSeg *bracketshape = new TGeoTubeSeg(kBracketRmin, kBracketRmax,
2313 kBracketHalfLength, -kBracketPhi/2, kBracketPhi/2);
2314
2315
2316 // We have the shapes: now create the real volumes
2317
2318 TGeoVolume *cfcone = new TGeoVolume("SSDCarbonFiberCone",
2319 coneshape,medSSDcf);
2320 cfcone->SetVisibility(kTRUE);
2321 cfcone->SetLineColor(4); // Blue
2322 cfcone->SetLineWidth(1);
2323 cfcone->SetFillColor(cfcone->GetLineColor());
2324 cfcone->SetFillStyle(4000); // 0% transparent
2325
2326 TGeoVolume *cfconeinsert = new TGeoVolume("SSDCarbonFiberConeInsert",
2327 coneinsertshape,medSSDste);
2328 cfconeinsert->SetVisibility(kTRUE);
2329 cfconeinsert->SetLineColor(2); // Red
2330 cfconeinsert->SetLineWidth(1);
2331 cfconeinsert->SetFillColor(cfconeinsert->GetLineColor());
2332 cfconeinsert->SetFillStyle(4050); // 50% transparent
2333
2334 TGeoVolume *cfconefoam1 = new TGeoVolume("SSDCarbonFiberConeFoam1",
2335 conefoam1shape,medSSDroh);
2336 cfconefoam1->SetVisibility(kTRUE);
2337 cfconefoam1->SetLineColor(3); // Green
2338 cfconefoam1->SetLineWidth(1);
2339 cfconefoam1->SetFillColor(cfconefoam1->GetLineColor());
2340 cfconefoam1->SetFillStyle(4050); // 50% transparent
2341
2342 TGeoVolume *cfconefoam2 = new TGeoVolume("SSDCarbonFiberConeFoam2",
2343 conefoam2shape,medSSDroh);
2344 cfconefoam2->SetVisibility(kTRUE);
2345 cfconefoam2->SetLineColor(3); // Green
2346 cfconefoam2->SetLineWidth(1);
2347 cfconefoam2->SetFillColor(cfconefoam2->GetLineColor());
2348 cfconefoam2->SetFillStyle(4050); // 50% transparent
2349
2350 TGeoVolume *coolinghole = new TGeoVolume("SSDCoolingHole",
2351 coolingholeshape,medSSDair);
2352 coolinghole->SetVisibility(kTRUE);
2353 coolinghole->SetLineColor(5); // Yellow
2354 coolinghole->SetLineWidth(1);
2355 coolinghole->SetFillColor(coolinghole->GetLineColor());
2356 coolinghole->SetFillStyle(4090); // 90% transparent
2357
a30e33f0 2358 TGeoVolume *coolinghole2 = new TGeoVolume("SSDCoolingHole2",
2359 coolinghole2shape,medSSDair);
2360 coolinghole2->SetVisibility(kTRUE);
2361 coolinghole2->SetLineColor(5); // Yellow
2362 coolinghole2->SetLineWidth(1);
2363 coolinghole2->SetFillColor(coolinghole2->GetLineColor());
2364 coolinghole2->SetFillStyle(4090); // 90% transparent
2365
2366 TGeoVolume *coolinghole3 = new TGeoVolume("SSDCoolingHole3",
2367 coolinghole3shape,medSSDair);
2368 coolinghole3->SetVisibility(kTRUE);
2369 coolinghole3->SetLineColor(5); // Yellow
2370 coolinghole3->SetLineWidth(1);
2371 coolinghole3->SetFillColor(coolinghole3->GetLineColor());
2372 coolinghole3->SetFillStyle(4090); // 90% transparent
2373
3a299c65 2374 TGeoVolume *mountinghole = new TGeoVolume("SSDMountingHole",
2375 mountingholeshape,medSSDair);
2376 mountinghole->SetVisibility(kTRUE);
2377 mountinghole->SetLineColor(5); // Yellow
2378 mountinghole->SetLineWidth(1);
2379 mountinghole->SetFillColor(mountinghole->GetLineColor());
2380 mountinghole->SetFillStyle(4090); // 90% transparent
2381
2382 TGeoVolume *mountinghole2 = new TGeoVolume("SSDMountingHole2",
2383 mountinghole2shape,medSSDair);
2384 mountinghole2->SetVisibility(kTRUE);
2385 mountinghole2->SetLineColor(5); // Yellow
2386 mountinghole2->SetLineWidth(1);
2387 mountinghole2->SetFillColor(mountinghole2->GetLineColor());
2388 mountinghole2->SetFillStyle(4090); // 90% transparent
2389
2390 TGeoVolume *mountinghole3 = new TGeoVolume("SSDMountingHole3",
2391 mountinghole3shape,medSSDair);
2392 mountinghole3->SetVisibility(kTRUE);
2393 mountinghole3->SetLineColor(5); // Yellow
2394 mountinghole3->SetLineWidth(1);
2395 mountinghole3->SetFillColor(mountinghole3->GetLineColor());
2396 mountinghole3->SetFillStyle(4090); // 90% transparent
2397
2398 TGeoVolume *wing = new TGeoVolume("SSDWing",wingshape,medSSDcf);
2399 wing->SetVisibility(kTRUE);
2400 wing->SetLineColor(4); // Blue
2401 wing->SetLineWidth(1);
2402 wing->SetFillColor(wing->GetLineColor());
2403 wing->SetFillStyle(4000); // 0% transparent
2404
2405 TGeoVolume *cablehole = new TGeoVolume("SSDCableHole",
2406 cableholeshape,medSSDair);
2407 cablehole->SetVisibility(kTRUE);
2408 cablehole->SetLineColor(5); // Yellow
2409 cablehole->SetLineWidth(1);
2410 cablehole->SetFillColor(cablehole->GetLineColor());
2411 cablehole->SetFillStyle(4090); // 90% transparent
2412
2413 TGeoVolume *winginsert = new TGeoVolume("SSDWingInsert",
2414 winginsertshape,medSSDste);
2415 winginsert->SetVisibility(kTRUE);
2416 winginsert->SetLineColor(2); // Red
2417 winginsert->SetLineWidth(1);
2418 winginsert->SetFillColor(winginsert->GetLineColor());
2419 winginsert->SetFillStyle(4050); // 50% transparent
2420
2421 TGeoVolume *bracket = new TGeoVolume("SSDMountingBracket",
2422 bracketshape,medSSDal);
2423 bracket->SetVisibility(kTRUE);
2424 bracket->SetLineColor(6); // Purple
2425 bracket->SetLineWidth(1);
2426 bracket->SetFillColor(bracket->GetLineColor());
2427 bracket->SetFillStyle(4000); // 0% transparent
2428
2429 // Mount up a cone
2430 for (Int_t i=0; i<(Int_t)(360./kMountingHolePhi); i++) {
2431 Double_t phiH = i*kMountingHolePhi + 0.5*kMountingHolePhi;
2432 cfconefoam2->AddNode(mountinghole,i+1, new TGeoRotation("", phiH, 0, 0));
2433 }
2434
a30e33f0 2435 for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
2436 Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
2437 cfconeinsert->AddNodeOverlap(coolinghole,i+1, new TGeoRotation("", phiH, 0, 0));
2438 }
2439
3a299c65 2440 cfconeinsert->AddNode(cfconefoam1,1,0);
2441 cfconeinsert->AddNode(cfconefoam2,1,0);
2442
2443 cfcone->AddNode(cfconeinsert,1,0);
2444
2445 for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
2446 Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
a30e33f0 2447 cfcone->AddNode(coolinghole2,i+1, new TGeoRotation("", phiH, 0, 0));
2448 cfcone->AddNode(coolinghole3,i+1, new TGeoRotation("", phiH, 0, 0));
3a299c65 2449 cfcone->AddNodeOverlap(cablehole,i+1, new TGeoRotation("", phiH, 0, 0));
2450 }
2451
2452 for (Int_t i=0; i<(Int_t)(360./kMountingHolePhi); i++) {
2453 Double_t phiH = i*kMountingHolePhi + 0.5*kMountingHolePhi;
2454 cfcone->AddNode(mountinghole2,i+1, new TGeoRotation("", phiH, 0, 0));
2455 cfcone->AddNode(mountinghole3,i+1, new TGeoRotation("", phiH, 0, 0));
2456 }
2457
2458 wing->AddNode(winginsert,1,0);
2459
2460 // Add all volumes in the Cone assembly
2461 vC->AddNode(cfcone,1,new TGeoTranslation(0,0,-kConeZPosition));
2462
2463 for (Int_t i=0; i<4; i++) {
85234543 2464 Double_t thetaW = kThetaWing + 90.*i + angleWideWing/2.;
2465 vC->AddNode(wing, i+1, new TGeoCombiTrans(0, 0, -kConeZPosition+kWingHalfThick,
3a299c65 2466 new TGeoRotation("",thetaW,180,0)));
2467 }
2468
2469 Double_t zBracket = kConeZPosition - coneshape->GetZ(9) +
a30e33f0 2470 2*bracketshape->GetDz();
3a299c65 2471 for (Int_t i=0; i<3; i++) {
2472 Double_t thetaB = 60 + 120.*i;
2473 vC->AddNode(bracket, i+1, new TGeoCombiTrans(0, 0, -zBracket,
2474 new TGeoRotation("",thetaB,0,0)));
2475 }
2476
2477 // Finally put everything in the mother volume
2478 moth->AddNode(cfcylinder,1,0);
2479
2480 moth->AddNode(vC, 1, 0 );
2481 moth->AddNode(vC, 2, new TGeoRotation("",180, 180, 0) );
2482
2483 // Some debugging if requested
2484 if(GetDebug(1)){
2485 vC->PrintNodes();
2486 vC->InspectShape();
2487 }
2488
2489 return;
172b0d90 2490}
2491
2492//______________________________________________________________________
543b7370 2493void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *moth,
2494 TGeoManager *mgr){
798b4e0c 2495//
2496// Creates the cable trays which are outside the ITS support cones
2497// but still inside the TPC
2498// This is now a stearing routine, the actual work is done by three
2499// specialized methods to avoid a really huge unique method
2500//
2501// Input:
2502// moth : the TGeoVolume owing the volume structure
2503// mgr : the GeoManager (default gGeoManager)
2504// Output:
2505//
2506// Created: 15 Nov 2009 Mario Sitta
2507//
2508
2509 TraySupportsSideA(moth, mgr);
2510
2511 ServicesCableSupportSPD(moth, mgr);
2512 ServicesCableSupportSDD(moth, mgr);
2513 ServicesCableSupportSSD(moth, mgr);
2514
2515 return;
2516}
2517
2518//______________________________________________________________________
2519void AliITSv11GeometrySupport::TraySupportsSideA(TGeoVolume *moth,
2520 TGeoManager *mgr){
2521//
2522// Creates the structure supporting the ITS cable trays on Side A
2523//
2524// Input:
2525// moth : the TGeoVolume owing the volume structure
2526// mgr : the GeoManager (default gGeoManager)
2527// Output:
2528//
2529// Created: 14 Dec 2009 Mario Sitta
2530// Updated: 26 Feb 2010 Mario Sitta
2531//
2532// Technical data are taken from AutoCAD drawings, L.Simonetti technical
2533// drawings and other (oral) information given by F.Tosello
2534//
2535
2536 // Dimensions and positions of the A-Side Cable Tray Support Ring
2537 // (0872/G/A/01)
2538 const Double_t kSuppRingYTrans = 110.00 *fgkmm;
2539 const Double_t kSuppRingZTrans =(1011.00+435.00) *fgkmm;
2540 const Double_t kSuppForwYTrans = 185.00 *fgkmm;
2541
2542 const Double_t kExtSuppRingSpace1 = 33.00 *fgkmm;
2543 const Double_t kExtSuppRingSpace2 = 45.00 *fgkmm;
2544 const Double_t kExtSuppRingSpcAbov = 30.00 *fgkmm;
2545 const Double_t kExtSuppRingBase = 491.50 *fgkmm;
2546 const Double_t kExtSuppRingInward = 35.00 *fgkmm;
2547 const Double_t kExtSuppRingRmax = 540.00 *fgkmm;
2548 const Double_t kExtSuppRingRint1 = 465.00 *fgkmm;
2549 const Double_t kExtSuppRingRint2 = 467.00 *fgkmm;
2550 const Double_t kExtSuppRingInnerHi = 450.00 *fgkmm;
2551 const Double_t kExtSuppRingInWide = 100.00 *fgkmm;
2552 const Double_t kExtSuppRingR7 = 7.00 *fgkmm;
2553 const Double_t kExtSuppRingR5 = 5.00 *fgkmm;
2554 const Double_t kExtSuppRingThick = 20.00 *fgkmm;
2555
2556 const Double_t kExtSuppRingSpcAng = 10.50 *TMath::DegToRad();
2557 const Double_t kExtSuppRingPartPhi = 15.00 *TMath::DegToRad();
2558 const Double_t kExtSuppRingIntAng = 7.00 *TMath::DegToRad();
2559 const Double_t kExtSuppRingBaseAng = 75.00 *TMath::DegToRad();
2560 const Double_t kExtSuppRingR7Ang = 100.00 *TMath::DegToRad(); // Guessed
2561
2562 const Int_t kExtSuppRingNPtsArc = 10; // N.points to approximate arc
2563
2564 const Double_t kIntSuppRingThick1 = 15.00 *fgkmm;
2565 const Double_t kIntSuppRingThick2 = 13.00 *fgkmm;
2566 const Double_t kIntSuppRingInward = 24.00 *fgkmm;
2567 const Double_t kIntSuppRingThick = 20.00 *fgkmm;
2568
2569 const Double_t kSuppCylHeight = 340.00 *fgkmm;
2570 const Double_t kSuppCylRint = 475.00 *fgkmm;
2571 const Double_t kSuppCylRext = 478.00 *fgkmm;
2572 const Double_t kSuppCylDispl = 137.70 *fgkmm;
2573
2574 const Double_t kSuppSpacerHeight = 30.00 *fgkmm;
2575 const Double_t kSuppSpacerThick = 10.00 *fgkmm;
2576
2577 const Double_t kSuppSpacerAngle = 15.00; // Degrees
2578
2579 const Double_t kSuppForwRingRint1 = 500.00 *fgkmm;
2580 const Double_t kSuppForwRingRint2 = 540.00 *fgkmm;
2581 const Double_t kSuppForwRingRext = 560.00 *fgkmm;
2582 const Double_t kSuppForwRingThikAll = 50.00 *fgkmm;
2583 const Double_t kSuppForwRingThikInt = 20.00 *fgkmm;
2584
2585 // (0872/G/B/01)
2586 const Double_t kSuppForwConeRmin = 558.00 *fgkmm;
2587 const Double_t kSuppForwConeRmax = 681.00 *fgkmm;
2588 const Double_t kSuppForwConeLen1 = 318.00 *fgkmm;
2589 const Double_t kSuppForwConeLen2 = 662.00 *fgkmm;
2590 const Double_t kSuppForwConeThick = 3.00 *fgkmm;
2591
2592 const Double_t kSuppBackRingPlacTop = 90.00 *fgkmm;
2593 const Double_t kSuppBackRingPlacSid = 50.00 *fgkmm;
2594 const Double_t kSuppBackRingHeight = 760.00 *fgkmm;
2595 const Double_t kSuppBackRingRext = 760.00 *fgkmm;
2596 const Double_t kSuppBackRingRint = 685.00 *fgkmm;
2597// const Double_t kSuppBackRingRint2 = 675.00 *fgkmm;
2598 const Double_t kSuppBackRingR10 = 10.00 *fgkmm;
2599 const Double_t kSuppBackRingBase = 739.00 *fgkmm;
2600 const Double_t kSuppBackRingThikAll = 50.00 *fgkmm;
2601 const Double_t kSuppBackRingThick1 = 20.00 *fgkmm;
2602 const Double_t kSuppBackRingThick2 = 20.00 *fgkmm;
2603
2604// const Double_t kSuppBackRingPlacAng = 10.00 *TMath::DegToRad();
2605 const Double_t kSuppBackRingPlacAng = 10.25 *TMath::DegToRad();//Fix ovlp.
2606 const Double_t kSuppBackRing2ndAng1 = 78.40 *TMath::DegToRad();
2607 const Double_t kSuppBackRing2ndAng2 = 45.00 *TMath::DegToRad();
2608
2609 const Int_t kSuppBackRingNPtsArc = 10; // N.points to approximate arc
2610
2611 // (0872/G/C/01)
2612 const Double_t kRearSuppZTransGlob =(1011.00+9315.00-6040.00) *fgkmm;
2613 const Double_t kBackRodZTrans = 2420.00 *fgkmm;
2614
2615 const Double_t kBackRodLength = 1160.00 *fgkmm;
2616 const Double_t kBackRodThickLen = 20.00 *fgkmm;
2617 const Double_t kBackRodDiameter = 20.00 *fgkmm;
2618
2619 const Double_t kSuppRearRingRint = 360.00 *fgkmm;
2620 const Double_t kSuppRearRingRext1 = 410.00 *fgkmm;
2621 const Double_t kSuppRearRingRext2 = 414.00 *fgkmm;
2622 const Double_t kSuppRearRingHeight = 397.00 *fgkmm;
2623 const Double_t kSuppRearRingTopWide = 111.87 *fgkmm;
2624 const Double_t kSuppRearRingBase = 451.50 *fgkmm;
2625 const Double_t kSuppRearRingBaseHi = 58.00 *fgkmm;
2626 const Double_t kSuppRearRingSideHi = 52.00 *fgkmm;
2627 const Double_t kSuppRearRingInside = 40.00 *fgkmm;
2628 const Double_t kSuppRearRingInsideHi= 12.00 *fgkmm;
2629 const Double_t kSuppRearRingThick = 20.00 *fgkmm;
2630 const Double_t kSuppRearRingXRodHole= 441.50 *fgkmm;
2631 const Double_t kSuppRearRingYRodHole= 42.00 *fgkmm;
2632
2633 const Double_t kSuppRearRing1stAng = 22.00 *TMath::DegToRad();
2634 const Double_t kSuppRearRingStepAng = 15.00 *TMath::DegToRad();
2635
2636 const Int_t kSuppRearRingNPtsArc = 10; // N.points to approximate arc
2637
2638
2639 // Local variables
2640 Double_t xprof[2*(15+kExtSuppRingNPtsArc)],yprof[2*(15+kExtSuppRingNPtsArc)];
2641 Double_t slp1, slp2, phi, xm, ym;
2642 Double_t xloc, yloc, zloc, rmin, rmax, deltaR;
2643 Int_t npoints;
2644
2645
2646 // The whole support as an assembly
2647 TGeoVolumeAssembly *trayASuppStruct = new TGeoVolumeAssembly("ITSsuppSideAStructure");
2648
2649
2650 // First create all needed shapes
2651
2652 // The External Ring (part of 0872/G/A/01): a really complex Xtru
2653 TGeoXtru *extSuppRing = new TGeoXtru(2);
2654
2655 // First the upper notch...
2656 xprof[ 0] = kExtSuppRingSpace1;
2657 yprof[ 0] = kExtSuppRingInnerHi + kExtSuppRingSpcAbov;
2658
2659 slp1 = TMath::Tan(TMath::Pi()/2 - kExtSuppRingSpcAng);
2660 IntersectCircle(slp1, xprof[0], yprof[0], kExtSuppRingRmax, 0., 0.,
2661 xprof[5], yprof[5], xm, ym); // Ignore dummy xm,ym
2662
2663 xprof[ 4] = xprof[5];
2664 yprof[ 4] = yprof[5] - kExtSuppRingR5/TMath::Tan(kExtSuppRingSpcAng);
2665 xprof[ 3] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/6));
2666 yprof[ 3] = yprof[4] - kExtSuppRingR5*( TMath::Sin(TMath::Pi()/6));
2667 xprof[ 2] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/3));
2668 yprof[ 2] = yprof[4] - kExtSuppRingR5*( TMath::Sin(TMath::Pi()/3));
2669 xprof[ 1] = xprof[4] - kExtSuppRingR5;
2670 yprof[ 1] = yprof[4] - kExtSuppRingR5;
2671
2672 Int_t indx = 5+kExtSuppRingNPtsArc;
2673 // ...then the external arc, approximated with segments,...
2674 xprof[indx] = kExtSuppRingBase;
2675 yprof[indx] = TMath::Sqrt(kExtSuppRingRmax*kExtSuppRingRmax -
2676 kExtSuppRingBase*kExtSuppRingBase);
2677 Double_t alphamin = TMath::ASin(kExtSuppRingSpace2/kExtSuppRingRmax);
2678 Double_t alphamax = TMath::Pi()/2 -
2679 TMath::ASin(yprof[5+kExtSuppRingNPtsArc]/kExtSuppRingRmax);
2680
2681 for (Int_t jp = 1; jp < kExtSuppRingNPtsArc; jp++) {
2682 Double_t alpha = jp*(alphamax-alphamin)/kExtSuppRingNPtsArc;
2683 xprof[5+jp] = kExtSuppRingRmax*TMath::Sin(alpha);
2684 yprof[5+jp] = kExtSuppRingRmax*TMath::Cos(alpha);
2685 }
2686 // ...and finally the interior profile
2687 xprof[indx+1] = kExtSuppRingBase;
2688 yprof[indx+1] = kSuppRingYTrans;
2689 xprof[indx+2] = xprof[indx+1] - kExtSuppRingInward;
2690 yprof[indx+2] = yprof[indx+1];
2691
2692 phi = TMath::Pi()/2 - 4*kExtSuppRingPartPhi - kExtSuppRingIntAng;
2693 slp1 = TMath::Tan(TMath::Pi() - kExtSuppRingBaseAng);
2694 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2695 xm = kExtSuppRingRint2*TMath::Cos(phi);
2696 ym = kExtSuppRingRint2*TMath::Sin(phi);
2697 IntersectLines(slp1, xprof[indx+2], yprof[indx+2], slp2, xm, ym,
2698 xprof[indx+3], yprof[indx+3]);
2699
2700 slp1 = slp2;
2701 phi += kExtSuppRingPartPhi;
2702 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2703 xm = kExtSuppRingRint1*TMath::Cos(phi);
2704 ym = kExtSuppRingRint1*TMath::Sin(phi);
2705 IntersectLines(slp1, xprof[indx+3], yprof[indx+3], slp2, xm, ym,
2706 xprof[indx+4], yprof[indx+4]);
2707
2708 slp1 = slp2;
2709 phi += kExtSuppRingPartPhi;
2710 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2711 xm = kExtSuppRingRint2*TMath::Cos(phi);
2712 ym = kExtSuppRingRint2*TMath::Sin(phi);
2713 IntersectLines(slp1, xprof[indx+4], yprof[indx+4], slp2, xm, ym,
2714 xprof[indx+5], yprof[indx+5]);
2715
2716 slp1 = slp2;
2717 phi += kExtSuppRingPartPhi;
2718 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2719 xm = kExtSuppRingRint1*TMath::Cos(phi);
2720 ym = kExtSuppRingRint1*TMath::Sin(phi);
2721 IntersectLines(slp1, xprof[indx+5], yprof[indx+5], slp2, xm, ym,
2722 xprof[indx+6], yprof[indx+6]);
2723
2724 xprof[indx+9] = kExtSuppRingInWide;
2725 yprof[indx+9] = kExtSuppRingInnerHi;
2726 xprof[indx+8] = xprof[indx+9] +
2727 (1 - TMath::Cos(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
2728 yprof[indx+8] = yprof[indx+9] +
2729 ( TMath::Sin(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
2730 xprof[indx+7] = xprof[indx+9] +
2731 (1 + TMath::Cos(kExtSuppRingR7Ang ))*kExtSuppRingR7;
2732 yprof[indx+7] = yprof[indx+9] +
2733 ( TMath::Sin(kExtSuppRingR7Ang ))*kExtSuppRingR7;
2734 // Gosh, we did the right side! now reflex on the left side
2735 npoints = (sizeof(xprof)/sizeof(Double_t))/2;
2736 for (Int_t jp = 0; jp < npoints; jp++) {
2737 xprof[npoints+jp] = -xprof[npoints-1-jp];
2738 yprof[npoints+jp] = yprof[npoints-1-jp];
2739 }
2740 // wow! now the actual Xtru
2741 extSuppRing->DefinePolygon(2*npoints, xprof, yprof);
2742 extSuppRing->DefineSection(0,0);
2743 extSuppRing->DefineSection(1,kExtSuppRingThick);
2744
2745 // The Internal Ring (part of 0872/G/A/01): another complex Xtru
2746 TGeoXtru *intSuppRing = new TGeoXtru(2);
2747
2748 // First the external profile...
2749 npoints = 0;
2750
2751 slp1 = 0;
2752 phi = TMath::Pi()/2 - kExtSuppRingPartPhi - kExtSuppRingIntAng;
2753 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2754 xm = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
2755 ym = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
2756 IntersectLines(slp1, 0, kExtSuppRingInnerHi+kExtSuppRingSpcAbov,
2757 slp2, xm, ym,
2758 xprof[npoints], yprof[npoints]);
2759 npoints++;
2760
2761 slp1 = slp2;
2762 phi -= kExtSuppRingPartPhi;
2763 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2764 xm = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
2765 ym = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
2766 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
2767 slp2, xm, ym,
2768 xprof[npoints], yprof[npoints]);
2769 npoints++;
2770
2771 slp1 = slp2;
2772 phi -= kExtSuppRingPartPhi;
2773 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2774 xm = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
2775 ym = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
2776 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
2777 slp2, xm, ym,
2778 xprof[npoints], yprof[npoints]);
2779 npoints++;
2780
2781 slp1 = slp2;
2782 phi -= kExtSuppRingPartPhi;
2783 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
2784 xm = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
2785 ym = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
2786 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
2787 slp2, xm, ym,
2788 xprof[npoints], yprof[npoints]);
2789 npoints++;
2790
2791 xprof[npoints] = kExtSuppRingBase-kIntSuppRingInward;
2792 yprof[npoints] = Yfrom2Points(xprof[npoints-1], yprof[npoints-1], xm, ym,
2793 xprof[npoints]);
2794 npoints++;
2795
2796 xprof[npoints] = xprof[npoints-1];
2797 yprof[npoints] = kSuppRingYTrans;
2798 npoints++;
2799 // ...and then the interior profile, which is identical to extSuppRing one
2800 for (Int_t jp=0; jp < 8; jp++) {
2801 xprof[npoints] = extSuppRing->GetX(17+jp);
2802 yprof[npoints] = extSuppRing->GetY(17+jp);
2803 npoints++;
2804 }
2805 // We did the right side! now reflex on the left side
2806 for (Int_t jp = 0; jp < npoints; jp++) {
2807 xprof[npoints+jp] = -xprof[npoints-1-jp];
2808 yprof[npoints+jp] = yprof[npoints-1-jp];
2809 }
2810 // And now the actual Xtru
2811 intSuppRing->DefinePolygon(2*npoints, xprof, yprof);
2812 intSuppRing->DefineSection(0,0);
2813 intSuppRing->DefineSection(1,kIntSuppRingThick);
2814
2815 // The intermediate cylinder (0872/G/A/03): a TubeSeg
2816 alphamin = TMath::ASin(kSuppCylDispl/kSuppCylRint)*TMath::RadToDeg();
2817 alphamax = 180 - alphamin;
2818 TGeoTubeSeg *interCylind = new TGeoTubeSeg(kSuppCylRint, kSuppCylRext,
2819 kSuppCylHeight/2, alphamin, alphamax);
2820
2821 // The spacer (0872/G/A/03): a simple Xtru
2822 TGeoXtru *suppSpacer = new TGeoXtru(2);
2823
2824 xprof[0] = kSuppSpacerHeight;
2825 yprof[0] = kSuppSpacerThick;
2826 xprof[1] = xprof[0];
2827 yprof[1] = 0;
2828 xprof[2] = 0;
2829 yprof[2] = 0;
2830 xprof[3] = kSuppSpacerThick*SinD(kSuppSpacerAngle);
2831 yprof[3] = yprof[0];
2832
2833 suppSpacer->DefinePolygon(4, xprof, yprof);
2834 suppSpacer->DefineSection(0,-kSuppCylHeight/2);
2835 suppSpacer->DefineSection(1, kSuppCylHeight/2);
2836
2837 // The forward ring (0872/G/B/02): a Pcon (slight oversimplification)
2838 Double_t rmean = (kSuppForwRingRint1+kSuppForwRingRext)/2;
2839 alphamin = TMath::ASin(kSuppForwYTrans/rmean)*TMath::RadToDeg();
2840 alphamax = 180 - alphamin;
2841
2842 TGeoPcon *forwardRing = new TGeoPcon(alphamin,alphamax-alphamin,4);
2843
2844 forwardRing->DefineSection(0,0,
2845 kSuppForwRingRint1,kSuppForwRingRext);
2846 forwardRing->DefineSection(1,kSuppForwRingThikInt,
2847 kSuppForwRingRint1,kSuppForwRingRext);
2848 forwardRing->DefineSection(2,kSuppForwRingThikInt,
2849 kSuppForwRingRint2,kSuppForwRingRext);
2850 forwardRing->DefineSection(3,kSuppForwRingThikAll,
2851 kSuppForwRingRint2,kSuppForwRingRext);
2852
2853 // The forward cone (0872/G/B/03): a TGeoPcon
2854 TGeoPcon *forwardCone = new TGeoPcon(alphamin,alphamax-alphamin,3);
2855
2856 forwardCone->DefineSection(0,0,
2857 kSuppForwConeRmin-kSuppForwConeThick,
2858 kSuppForwConeRmin);
2859 forwardCone->DefineSection(1,kSuppForwConeLen1,
2860 kSuppForwConeRmin-kSuppForwConeThick,
2861 kSuppForwConeRmin);
2862 forwardCone->DefineSection(2,kSuppForwConeLen1+kSuppForwConeLen2,
2863 kSuppForwConeRmax-kSuppForwConeThick,
2864 kSuppForwConeRmax);
2865
2866 // The first part of the Back Ring (part of 0872/G/B/01): a complex Xtru
2867 TGeoXtru *firstSuppBackRing = new TGeoXtru(2);
2868
2869 // First the external profile... (the arc is approximated with segments)
2870 npoints = 0;
2871
2872 xprof[npoints] = kSuppBackRingPlacTop;
2873 yprof[npoints] = kSuppBackRingHeight;
2874 npoints++;
2875
2876 alphamax = TMath::Pi()/2 - TMath::ASin(kSuppBackRingPlacTop/kSuppBackRingRext);
2877 alphamin = TMath::ASin((kSuppForwYTrans+kSuppBackRingPlacSid)/kSuppBackRingRext);
2878
2879 xprof[npoints] = xprof[npoints-1];
2880 yprof[npoints] = kSuppBackRingRext*TMath::Sin(alphamax);
2881 npoints++;
2882
2883 for (Int_t jp = 1; jp <= kSuppBackRingNPtsArc; jp++) {
2884 Double_t alpha = alphamax - jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
2885 xprof[npoints] = kSuppBackRingRext*TMath::Cos(alpha);
2886 yprof[npoints] = kSuppBackRingRext*TMath::Sin(alpha);
2887 npoints++;
2888 }
2889
2890 xprof[npoints] = kSuppBackRingBase -
2891 kSuppBackRingPlacSid*TMath::Tan(kSuppBackRingPlacAng);
2892 yprof[npoints] = yprof[npoints-1];
2893 npoints++;
2894
2895 xprof[npoints] = kSuppBackRingBase;
2896 yprof[npoints] = kSuppForwYTrans;
2897 npoints++;
2898 // ...then the internal profile (the arc is approximated with segments)
2899 alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint);
2900 alphamax = TMath::Pi()/2;
2901
2902 for (Int_t jp = 0; jp < kSuppBackRingNPtsArc; jp++) {
2903 Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
2904 xprof[npoints] = kSuppBackRingRint*TMath::Cos(alpha);
2905 yprof[npoints] = kSuppBackRingRint*TMath::Sin(alpha);
2906 npoints++;
2907 }
2908
2909 xprof[npoints] = 0;
2910 yprof[npoints] = kSuppBackRingRint;
2911 npoints++;
2912 // We did the right side! now reflex on the left side (except last point)
2913 for (Int_t jp = 0; jp < npoints-1; jp++) {
2914 xprof[npoints+jp] = -xprof[npoints-jp-2];
2915 yprof[npoints+jp] = yprof[npoints-jp-2];
2916 }
2917 // And now the actual Xtru
2918 firstSuppBackRing->DefinePolygon(2*npoints-1, xprof, yprof);
2919 firstSuppBackRing->DefineSection(0,0);
2920 firstSuppBackRing->DefineSection(1,kSuppBackRingThick1);
2921
2922 // The second part of the Back Ring (part of 0872/G/B/01): a Pcon
2923 // (slight oversimplification)
2924 alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint)*TMath::RadToDeg();
2925 alphamax = 180 - alphamin;
2926
2927 TGeoPcon *secondSuppBackRing = new TGeoPcon(alphamin,alphamax-alphamin,6);
2928
2929 deltaR = kSuppBackRingThick2/TMath::Sin(kSuppBackRing2ndAng1);
2930 rmin = kSuppBackRingRint - kSuppBackRingThick1/TMath::Tan(kSuppBackRing2ndAng1);
2931 rmax = rmin + deltaR + kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
2932 secondSuppBackRing->DefineSection(0, 0, rmin, rmax);
2933
2934 zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1/3));
2935 rmax -= kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1/3);
2936 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
2937 secondSuppBackRing->DefineSection(1, zloc, rmin, rmax);
2938
2939 zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1*2/3));
2940 rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1*2/3);
2941 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
2942 secondSuppBackRing->DefineSection(2, zloc, rmin, rmax);
2943
2944 zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1));
2945 rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
2946 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
2947 secondSuppBackRing->DefineSection(3, zloc, rmin, rmax);
2948
2949 slp1 = TMath::Tan(kSuppBackRing2ndAng2);
2950 slp2 = TMath::Tan(TMath::Pi()/2 + kSuppBackRing2ndAng1);
2951 IntersectLines(-slp1,kSuppBackRingThikAll,deltaR/2,
2952 slp2,kSuppBackRingThikAll,deltaR,
2953 xm, ym);
2954
2955 zloc = xm - kSuppBackRingThick1;
2956 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
2957 rmax = rmin + deltaR;
2958 secondSuppBackRing->DefineSection(4, zloc, rmin, rmax);
2959
2960 zloc = kSuppBackRingThikAll - kSuppBackRingThick1;
2961 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
2962 rmax = rmin + deltaR/2;
2963 secondSuppBackRing->DefineSection(5, zloc, rmin, rmax);
2964
2965 // The supporting rod: a Tube
2966 TGeoTube *suppRod = new TGeoTube(0, kBackRodDiameter/2,
2967 (kBackRodLength - kBackRodThickLen)/2);
2968
2969 // The Back Ring (0872/G/C/01): another complex Xtru
2970 TGeoXtru *suppRearRing = new TGeoXtru(2);
2971
2972 // First the external profile...
2973 npoints = 0;
2974
2975 xprof[npoints] = kSuppRearRingTopWide;
2976 yprof[npoints] = kSuppRearRingHeight;
2977 npoints++;
2978
2979 phi = kSuppRearRing1stAng;
2980 slp1 = TMath::Tan(TMath::Pi() - phi);
2981 phi += kSuppRearRingStepAng;
2982 slp2 = TMath::Tan(TMath::Pi() - phi);
2983 xm = kSuppRearRingRext2*TMath::Sin(phi);
2984 ym = kSuppRearRingRext2*TMath::Cos(phi);
2985 IntersectLines(slp1, kSuppRearRingTopWide, kSuppRearRingHeight,
2986 slp2, xm, ym,
2987 xprof[npoints], yprof[npoints]);
2988 npoints++;
2989
2990 slp1 = slp2;
2991 phi += kSuppRearRingStepAng;
2992 slp2 = TMath::Tan(TMath::Pi() - phi);
2993 xm = kSuppRearRingRext1*TMath::Sin(phi);
2994 ym = kSuppRearRingRext1*TMath::Cos(phi);
2995 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
2996 slp2, xm, ym,
2997 xprof[npoints], yprof[npoints]);
2998 npoints++;
2999
3000 slp1 = slp2;
3001 phi += kSuppRearRingStepAng;
3002 slp2 = TMath::Tan(TMath::Pi() - phi);
3003 xm = kSuppRearRingRext2*TMath::Sin(phi);
3004 ym = kSuppRearRingRext2*TMath::Cos(phi);
3005 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3006 slp2, xm, ym,
3007 xprof[npoints], yprof[npoints]);
3008 npoints++;
3009
3010 slp1 = slp2;
3011 slp2 = 0;
3012 xm = kSuppRearRingBase;
3013 ym = kSuppRearRingBaseHi + kSuppRearRingSideHi;
3014 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3015 slp2, xm, ym,
3016 xprof[npoints], yprof[npoints]);
3017 npoints++;
3018
3019 xprof[npoints] = kSuppRearRingBase;
3020 yprof[npoints] = kSuppRearRingBaseHi + kSuppRearRingSideHi;
3021 npoints++;
3022 xprof[npoints] = xprof[npoints - 1];
3023 yprof[npoints] = kSuppRearRingBaseHi;
3024 npoints++;
3025 xprof[npoints] = xprof[npoints - 1] - kSuppRearRingInside;
3026 yprof[npoints] = yprof[npoints - 1];
3027 npoints++;
3028 xprof[npoints] = xprof[npoints - 1];
3029 yprof[npoints] = yprof[npoints - 1] + kSuppRearRingInsideHi;
3030 npoints++;
3031 // ...then the internal arc, approximated with segments,...
3032 xprof[npoints] = kSuppRearRingRint;
3033 yprof[npoints] = yprof[npoints - 1];
3034
3035 alphamin = TMath::ASin(kSuppRearRingBaseHi/kSuppRearRingRint);
3036 alphamax = TMath::Pi()/2;
3037
3038 for (Int_t jp = 1; jp < kSuppRearRingNPtsArc; jp++) {
3039 Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppRearRingNPtsArc;
3040 xprof[npoints+jp] = kSuppRearRingRint*TMath::Cos(alpha);
3041 yprof[npoints+jp] = kSuppRearRingRint*TMath::Sin(alpha);
3042 }
3043
3044 xprof[npoints+kSuppRearRingNPtsArc] = 0;
3045 yprof[npoints+kSuppRearRingNPtsArc] = kSuppRearRingRint;
3046 // We did the right side! now reflex on the left side
3047 Int_t nTotalPoints = npoints+kSuppRearRingNPtsArc;
3048 for (Int_t jp = 0; jp < nTotalPoints; jp++) {
3049 xprof[nTotalPoints+1+jp] = -xprof[nTotalPoints-1-jp];
3050 yprof[nTotalPoints+1+jp] = yprof[nTotalPoints-1-jp];
3051 }
3052
3053 // And now the actual Xtru
3054 suppRearRing->DefinePolygon(2*nTotalPoints+1, xprof, yprof);
3055 suppRearRing->DefineSection(0,0);
3056 suppRearRing->DefineSection(1,kSuppRearRingThick);
3057
3058
3059 // We have all shapes: now create the real volumes
3060 TGeoMedium *medAl = mgr->GetMedium("ITS_ANTICORODAL$");
3061
3062 TGeoVolume *sideAExtSuppRing = new TGeoVolume("ITSsuppSideAExtSuppRing",
3063 extSuppRing, medAl);
3064
3065 sideAExtSuppRing->SetVisibility(kTRUE);
3066 sideAExtSuppRing->SetLineColor(kMagenta+1);
3067 sideAExtSuppRing->SetLineWidth(1);
3068 sideAExtSuppRing->SetFillColor(sideAExtSuppRing->GetLineColor());
3069 sideAExtSuppRing->SetFillStyle(4000); // 0% transparent
3070
3071 TGeoVolume *sideAIntSuppRing = new TGeoVolume("ITSsuppSideAIntSuppRing",
3072 intSuppRing, medAl);
3073
3074 sideAIntSuppRing->SetVisibility(kTRUE);
3075 sideAIntSuppRing->SetLineColor(kMagenta+1);
3076 sideAIntSuppRing->SetLineWidth(1);
3077 sideAIntSuppRing->SetFillColor(sideAIntSuppRing->GetLineColor());
3078 sideAIntSuppRing->SetFillStyle(4000); // 0% transparent
3079
3080 TGeoVolume *sideASuppCyl = new TGeoVolume("ITSsuppSideASuppCyl",
3081 interCylind, medAl);
3082
3083 sideASuppCyl->SetVisibility(kTRUE);
3084 sideASuppCyl->SetLineColor(kMagenta+1);
3085 sideASuppCyl->SetLineWidth(1);
3086 sideASuppCyl->SetFillColor(sideASuppCyl->GetLineColor());
3087 sideASuppCyl->SetFillStyle(4000); // 0% transparent
3088
3089 TGeoVolume *sideASuppSpacer = new TGeoVolume("ITSsuppSideASuppSpacer",
3090 suppSpacer, medAl);
3091
3092 sideASuppSpacer->SetVisibility(kTRUE);
3093 sideASuppSpacer->SetLineColor(kMagenta+1);
3094 sideASuppSpacer->SetLineWidth(1);
3095 sideASuppSpacer->SetFillColor(sideASuppSpacer->GetLineColor());
3096 sideASuppSpacer->SetFillStyle(4000); // 0% transparent
3097
3098 TGeoVolume *sideASuppForwRing = new TGeoVolume("ITSsuppSideASuppForwRing",
3099 forwardRing, medAl);
3100
3101 sideASuppForwRing->SetVisibility(kTRUE);
3102 sideASuppForwRing->SetLineColor(kMagenta+1);
3103 sideASuppForwRing->SetLineWidth(1);
3104 sideASuppForwRing->SetFillColor(sideASuppForwRing->GetLineColor());
3105 sideASuppForwRing->SetFillStyle(4000); // 0% transparent
3106
3107 TGeoVolume *sideASuppForwCone = new TGeoVolume("ITSsuppSideASuppForwCone",
3108 forwardCone, medAl);
3109
3110 sideASuppForwCone->SetVisibility(kTRUE);
3111 sideASuppForwCone->SetLineColor(kMagenta+1);
3112 sideASuppForwCone->SetLineWidth(1);
3113 sideASuppForwCone->SetFillColor(sideASuppForwCone->GetLineColor());
3114 sideASuppForwCone->SetFillStyle(4000); // 0% transparent
3115
3116 TGeoVolume *sideAFirstSuppBackRing = new TGeoVolume("ITSsuppSideAFirstSuppBackRing",
3117 firstSuppBackRing, medAl);
3118
3119 sideAFirstSuppBackRing->SetVisibility(kTRUE);
3120 sideAFirstSuppBackRing->SetLineColor(kMagenta+1);
3121 sideAFirstSuppBackRing->SetLineWidth(1);
3122 sideAFirstSuppBackRing->SetFillColor(sideAFirstSuppBackRing->GetLineColor());
3123 sideAFirstSuppBackRing->SetFillStyle(4000); // 0% transparent
3124
3125 TGeoVolume *sideASecondSuppBackRing = new TGeoVolume("ITSsuppSideASecondSuppBackRing",
3126 secondSuppBackRing, medAl);
3127
3128 sideASecondSuppBackRing->SetVisibility(kTRUE);
3129 sideASecondSuppBackRing->SetLineColor(kMagenta+1);
3130 sideASecondSuppBackRing->SetLineWidth(1);
3131 sideASecondSuppBackRing->SetFillColor(sideASecondSuppBackRing->GetLineColor());
3132 sideASecondSuppBackRing->SetFillStyle(4000); // 0% transparent
3133
3134 TGeoVolume *sideASuppRod = new TGeoVolume("ITSsuppSideASuppRod",
3135 suppRod, medAl);
3136
3137 sideASuppRod->SetVisibility(kTRUE);
3138 sideASuppRod->SetLineColor(kMagenta+1);
3139 sideASuppRod->SetLineWidth(1);
3140 sideASuppRod->SetFillColor(sideASuppRod->GetLineColor());
3141 sideASuppRod->SetFillStyle(4000); // 0% transparent
3142
3143 TGeoVolume *sideASuppRearRing = new TGeoVolume("ITSsuppSideASuppRearRing",
3144 suppRearRing, medAl);
3145
3146 sideASuppRearRing->SetVisibility(kTRUE);
3147 sideASuppRearRing->SetLineColor(kMagenta+1);
3148 sideASuppRearRing->SetLineWidth(1);
3149 sideASuppRearRing->SetFillColor(sideASuppRearRing->GetLineColor());
3150 sideASuppRearRing->SetFillStyle(4000); // 0% transparent
3151
3152
3153 // Now build up the support structure
3154 zloc = kSuppRingZTrans;
3155 trayASuppStruct->AddNode(sideAExtSuppRing, 1,
3156 new TGeoTranslation(0, 0, zloc) );
3157 trayASuppStruct->AddNode(sideAExtSuppRing, 2,
3158 new TGeoCombiTrans( 0, 0, zloc,
3159 new TGeoRotation("",180,0,0)));
3160
3161 zloc += kExtSuppRingThick;
3162 trayASuppStruct->AddNode(sideAIntSuppRing, 1,
3163 new TGeoTranslation(0, 0, zloc) );
3164 trayASuppStruct->AddNode(sideAIntSuppRing, 2,
3165 new TGeoCombiTrans( 0, 0, zloc,
3166 new TGeoRotation("",180,0,0)));
3167
3168 xloc = kExtSuppRingBase - kIntSuppRingInward;
3169 yloc = kSuppRingYTrans;
3170 zloc += (kIntSuppRingThick + kSuppCylHeight/2);
3171 trayASuppStruct->AddNode(sideASuppCyl, 1,
3172 new TGeoTranslation(0, 0, zloc) );
3173 trayASuppStruct->AddNode(sideASuppCyl, 2,
3174 new TGeoCombiTrans( 0, 0, zloc,
3175 new TGeoRotation("",180,0,0)));
3176 trayASuppStruct->AddNode(sideASuppSpacer, 1,
3177 new TGeoCombiTrans( xloc, yloc, zloc,
3178 new TGeoRotation("",90+kSuppSpacerAngle,0,0)));
3179 trayASuppStruct->AddNode(sideASuppSpacer, 2,
3180 new TGeoCombiTrans(-xloc, yloc, zloc,
3181 new TGeoRotation("",0,180,kSuppSpacerAngle-90)));
3182 trayASuppStruct->AddNode(sideASuppSpacer, 3,
3183 new TGeoCombiTrans( xloc,-yloc, zloc,
3184 new TGeoRotation("",180,180,kSuppSpacerAngle-90)));
3185 trayASuppStruct->AddNode(sideASuppSpacer, 4,
3186 new TGeoCombiTrans(-xloc,-yloc, zloc,
3187 new TGeoRotation("",270+kSuppSpacerAngle,0,0)));
3188
3189
3190 zloc += kSuppCylHeight/2;
3191 trayASuppStruct->AddNode(sideAIntSuppRing, 3,
3192 new TGeoTranslation(0, 0, zloc) );
3193 trayASuppStruct->AddNode(sideAIntSuppRing, 4,
3194 new TGeoCombiTrans( 0, 0, zloc,
3195 new TGeoRotation("",180,0,0)));
3196
3197 zloc += kIntSuppRingThick;
3198 trayASuppStruct->AddNode(sideAExtSuppRing, 3,
3199 new TGeoTranslation(0, 0, zloc) );
3200 trayASuppStruct->AddNode(sideAExtSuppRing, 4,
3201 new TGeoCombiTrans( 0, 0, zloc,
3202 new TGeoRotation("",180,0,0)));
3203
3204 zloc += kExtSuppRingThick;
3205 trayASuppStruct->AddNode(sideASuppForwRing, 1,
3206 new TGeoTranslation(0, 0, zloc) );
3207 trayASuppStruct->AddNode(sideASuppForwRing, 2,
3208 new TGeoCombiTrans( 0, 0, zloc,
3209 new TGeoRotation("",180,0,0)));
3210
3211 zloc += kSuppForwRingThikAll;
3212 trayASuppStruct->AddNode(sideASuppForwCone, 1,
3213 new TGeoTranslation(0, 0, zloc) );
3214 trayASuppStruct->AddNode(sideASuppForwCone, 2,
3215 new TGeoCombiTrans( 0, 0, zloc,
3216 new TGeoRotation("",180,0,0)));
3217
3218 zloc += (kSuppForwConeLen1+kSuppForwConeLen2);
3219 trayASuppStruct->AddNode(sideAFirstSuppBackRing, 1,
3220 new TGeoTranslation(0, 0, zloc) );
3221 trayASuppStruct->AddNode(sideAFirstSuppBackRing, 2,
3222 new TGeoCombiTrans( 0, 0, zloc,
3223 new TGeoRotation("",180,0,0)));
3224
3225 zloc += kSuppBackRingThick1;
3226 trayASuppStruct->AddNode(sideASecondSuppBackRing, 1,
3227 new TGeoTranslation(0, 0, zloc) );
3228 trayASuppStruct->AddNode(sideASecondSuppBackRing, 2,
3229 new TGeoCombiTrans( 0, 0, zloc,
3230 new TGeoRotation("",180,0,0)));
3231
3232 xloc = kSuppRearRingXRodHole;
3233 yloc = kSuppRearRingBaseHi + kSuppRearRingYRodHole;
3234 zloc = kRearSuppZTransGlob - kBackRodZTrans + suppRod->GetDz();
3235 trayASuppStruct->AddNode(sideASuppRod, 1,
3236 new TGeoTranslation( xloc, yloc, zloc) );
3237 trayASuppStruct->AddNode(sideASuppRod, 2,
3238 new TGeoTranslation(-xloc, yloc, zloc) );
3239 trayASuppStruct->AddNode(sideASuppRod, 3,
3240 new TGeoTranslation( xloc,-yloc, zloc) );
3241 trayASuppStruct->AddNode(sideASuppRod, 4,
3242 new TGeoTranslation(-xloc,-yloc, zloc) );
3243
3244 zloc += suppRod->GetDz();
3245 trayASuppStruct->AddNode(sideASuppRearRing, 1,
3246 new TGeoTranslation( 0, 0, zloc) );
3247 trayASuppStruct->AddNode(sideASuppRearRing, 2,
3248 new TGeoCombiTrans( 0, 0, zloc,
3249 new TGeoRotation("",180,0,0)));
3250
3251
3252 // Finally put everything in the mother volume
3253 moth->AddNode(trayASuppStruct,1,0);
3254
3255 return;
3256}
3257
3258//______________________________________________________________________
3259void AliITSv11GeometrySupport::ServicesCableSupportSPD(TGeoVolume *moth,
3260 TGeoManager *mgr){
3261//
3262// Creates the all SPD cable trays which are outside the ITS support cones
3263// but still inside the TPC
3264// In order to avoid a huge monolithic routine, this method actually
3265// calls inner methods to create and assemble the various (macro)pieces
3266//
3267// Input:
3268// moth : the TGeoVolume owing the volume structure
3269// mgr : the GeoManager (default gGeoManager)
3270// Output:
3271//
3272// Created: ??? Bjorn S. Nilsen
3273// Updated: 15 Nov 2009 Mario Sitta
3274//
3275// Technical data are taken from AutoCAD drawings and other (oral)
3276// information given by F.Tosello
3277//
3278
3279 SPDCableTraysSideA(moth, mgr);
aa177c73 3280 SPDCableTraysSideC(moth, mgr);
798b4e0c 3281
3282}
3283
3284//______________________________________________________________________
3285void AliITSv11GeometrySupport::ServicesCableSupportSDD(TGeoVolume *moth,
3286 TGeoManager *mgr){
3287//
3288// Creates the all SDD cable trays which are outside the ITS support cones
3289// but still inside the TPC
3290// In order to avoid a huge monolithic routine, this method actually
3291// calls inner methods to create and assemble the various (macro)pieces
3292//
3293// Input:
3294// moth : the TGeoVolume owing the volume structure
3295// mgr : the GeoManager (default gGeoManager)
3296// Output:
3297//
3298// Created: 14 Dec 2009 Mario Sitta
3299//
3300
3301 SDDCableTraysSideA(moth, mgr);
aa177c73 3302 SDDCableTraysSideC(moth, mgr);
798b4e0c 3303
3304 return;
3305}
3306
3307//______________________________________________________________________
3308void AliITSv11GeometrySupport::ServicesCableSupportSSD(TGeoVolume *moth,
3309 TGeoManager *mgr){
3310//
3311// Creates the SSD cable trays which are outside the ITS support cones
3312// but still inside the TPC
3313// In order to avoid a huge monolithic routine, this method actually
3314// calls inner methods to create and assemble the various (macro)pieces
3315//
3316// Input:
3317// moth : the TGeoVolume owing the volume structure
3318// mgr : the GeoManager (default gGeoManager)
3319// Output:
3320//
3321// Created: 15 Nov 2009 Mario Sitta
3322//
3323
3324 SSDCableTraysSideA(moth, mgr);
aa177c73 3325 SSDCableTraysSideC(moth, mgr);
798b4e0c 3326
3327 return;
3328}
3329
3330//______________________________________________________________________
3331void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
3332 TGeoManager *mgr){
3333//
3334// Creates the SPD cable trays which are outside the ITS support cones
3335// but still inside the TPC on Side A
3336// (part of this code is taken or anyway inspired to ServicesCableSupport
3337// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
3338//
3339// Input:
3340// moth : the TGeoVolume owing the volume structure
3341// mgr : the GeoManager (default gGeoManager)
3342// Output:
3343//
3344// Created: 15 Feb 2010 Mario Sitta
96eb8210 3345// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes
57126ea1 3346// Updated: 08 Sep 2010 Mario Sitta
798b4e0c 3347//
3348// Technical data are taken from AutoCAD drawings, L.Simonetti technical
3349// drawings and other (oral) information given by F.Tosello and D.Elia
3350// (small differences with blueprints - e.g. -0.07mm in R1Trans and
3351// R2Trans - fix small overlaps; they are then compensated in positioning
3352// the Rear Tray to avoid its own overlaps with the rear supporting ring)
57126ea1 3353// Optical fibers and voltage cables are approximated with mean materials
3354// and square cross sections, but preserving the total material budget.
798b4e0c 3355//
3356
3357 // Overall position and rotation of the A-Side Cable Trays
3358 // (parts of 0872/G/D)
3359 const Double_t kTrayAR1Trans = 396.93 *fgkmm;
3360 const Double_t kTrayAR2Trans = 413.93 *fgkmm;
3361 const Double_t kTrayAZTrans = 1011.00 *fgkmm;
3362 const Double_t kTrayAZRot = (180-169.5);// Degrees
3363 const Double_t kTrayAFirstRotAng = 22.00; // Degrees
3364 const Double_t kTrayASecondRotAng = 15.00; // Degrees
3365
3366 const Double_t kForwardTrayWide = 94.00 *fgkmm;//!!!TO BE CHECKED!!!
3367 const Double_t kForwardTrayFirstHigh = 83.00 *fgkmm;//!!!TO BE CHECKED!!!
3368 const Double_t kForwardTraySecondHigh = 52.70 *fgkmm;//!!!TO BE CHECKED!!!
3369 const Double_t kForwardTrayTotalLen = 853.00 *fgkmm;
3370 const Double_t kForwardTrayFirstLen = 435.00 *fgkmm;
3371 const Double_t kForwardTrayWingWide = 16.00 *fgkmm;//!!!TO BE CHECKED!!!
3372 const Double_t kForwardTrayInterSpace = 18.00 *fgkmm;//!!!TO BE CHECKED!!!
3373 const Double_t kForwardTrayThick = 2.00 *fgkmm;
3374
3375 const Int_t kForwardSideNpoints = 6;
3376
3377 const Double_t kExternalTrayLen = 1200.00 *fgkmm;
3378 const Double_t kExternalTrayWide = kForwardTrayWide;
3379 const Double_t kExternalTrayHigh = kForwardTraySecondHigh;
3380 const Double_t kExternalTrayThick = kForwardTrayThick;
3381
57126ea1 3382 const Double_t kCoolingTubeRmin = 2.00 *fgkmm;
3383 const Double_t kCoolingTubeRmax = 3.00 *fgkmm;
798b4e0c 3384
3385 const Double_t kOpticalFibersSect = 8.696*fgkmm;//!!!ESTIMATED!!!
57126ea1 3386 const Double_t kLowVoltageCableSectCu = 7.675*fgkmm;// Computed
3387 const Double_t kLowVoltageCableHighPUR = 1.000*fgkmm;// Computed
3388 const Double_t kHiVoltageCableSectCu = 1.535*fgkmm;// Computed
3389 const Double_t kHiVoltageCableHighPUR = 0.500*fgkmm;// Computed
3390 const Double_t kCoaxCableSectCu = 6.140*fgkmm;//!!!ESTIMATED!!!
3391 const Double_t kCoaxCableHighPUR = 1.000*fgkmm;//!!!ESTIMATED!!!
96eb8210 3392
798b4e0c 3393
3394 // Local variables
3395 Double_t xprof[kForwardSideNpoints], yprof[kForwardSideNpoints];
3396 Double_t xloc, yloc, zloc, alpharot;
3397
3398
3399 // The two tray components as assemblies
3400 TGeoVolumeAssembly *cableTrayAForw =
3401 new TGeoVolumeAssembly("ITSsupportSPDTrayAForwRear");
3402 TGeoVolumeAssembly *cableTrayAExt =
3403 new TGeoVolumeAssembly("ITSsupportSPDTrayAExt");
3404
3405
3406 // First create all needed shapes
3407
3408 // The lower face of the forward tray: a BBox
3409 TGeoBBox *forwTrayLowerFace = new TGeoBBox(kForwardTrayWide/2,
3410 kForwardTrayThick/2,
3411 kForwardTrayTotalLen/2);
3412
3413 // The side face of the forward tray: a Xtru
3414 TGeoXtru *forwTraySideFace = new TGeoXtru(2);
3415 forwTraySideFace->SetName("ITSsuppSPDForwTraySide");
3416
3417 xprof[0] = 0;
3418 yprof[0] = kForwardTrayThick;
3419 xprof[1] = kForwardTrayTotalLen;
3420 yprof[1] = yprof[0];
3421 xprof[2] = xprof[1];
3422 yprof[2] = kForwardTraySecondHigh - kForwardTrayThick;
3423 xprof[3] = kForwardTrayFirstLen;
3424 yprof[3] = yprof[2];
3425 xprof[4] = xprof[3];
3426 yprof[4] = kForwardTrayFirstHigh - kForwardTrayThick;
3427 xprof[5] = xprof[0];
3428 yprof[5] = yprof[4];
3429
3430 forwTraySideFace->DefinePolygon(6, xprof, yprof);
3431 forwTraySideFace->DefineSection(0, 0);
3432 forwTraySideFace->DefineSection(1, kForwardTrayThick);
3433
3434 // The covers of the forward tray: two BBox's
3435 TGeoBBox *forwTrayShortCover = new TGeoBBox(kForwardTrayWide/2,
3436 kForwardTrayThick/2,
3437 kForwardTrayFirstLen/2);
3438
3439 TGeoBBox *forwTrayLongCover = new TGeoBBox(kForwardTrayWide/2,
3440 kForwardTrayThick/2,
3441 (kForwardTrayTotalLen - kForwardTrayFirstLen)/2);
3442
3443 // Each small wing of the forward tray: a BBox
3444 TGeoBBox *forwTrayWing = new TGeoBBox(kForwardTrayWingWide/2,
3445 (kForwardTrayFirstHigh-kForwardTraySecondHigh)/2,
3446 kForwardTrayThick/2);
3447
3448 // The internal plane of the forward tray: a BBox
3449 TGeoBBox *forwTrayPlane = new TGeoBBox(kForwardTrayWide/2-kForwardTrayThick,
3450 kForwardTrayThick/2,
3451 kForwardTrayTotalLen/2);
3452
3453 // The internal wall of the forward tray: a BBox
3454 TGeoBBox *forwTrayWall = new TGeoBBox(kForwardTrayThick/2,
3455 (kForwardTrayInterSpace-kForwardTrayThick)/2,
3456 kForwardTrayTotalLen/2);
3457
3458 // Each horizontal face of the external tray: a BBox
3459 TGeoBBox *extTrayHorFace = new TGeoBBox(kExternalTrayWide/2-kExternalTrayThick,
3460 kExternalTrayThick/2,
3461 kExternalTrayLen/2);
3462
3463 // Each vertical face of the external tray: a BBox
3464 TGeoBBox *extTrayVerFace = new TGeoBBox(kExternalTrayThick/2,
3465 kExternalTrayHigh/2,
3466 kExternalTrayLen/2);
3467
3468 // The internal wall of the external tray: a BBox
3469 TGeoBBox *extTrayWall = new TGeoBBox(kExternalTrayThick/2,
3470 (kForwardTrayInterSpace-kExternalTrayThick)/2,
3471 kExternalTrayLen/2);
3472
96eb8210 3473 // The cooling tube inside the forward tray: a Tube
798b4e0c 3474 Double_t zelong = (kForwardTraySecondHigh - 2*kForwardTrayThick
3475 - 2*forwTrayWall->GetDY() - kCoolingTubeRmax)*SinD(kTrayAZRot);
3476 Double_t zlen = (zelong + kForwardTrayTotalLen)/2;
96eb8210 3477 TGeoTube *coolTubeForw = new TGeoTube(0, kCoolingTubeRmax, zlen);
3478
3479 // The freon inside the forward tray tubes: a Tube
3480 TGeoTube *freonTubeForw = new TGeoTube(0, kCoolingTubeRmin, zlen);
798b4e0c 3481
3482 // The cooling tube inside the external tray: a Ctub
96eb8210 3483 TGeoCtub *coolTubeExt = new TGeoCtub(0, kCoolingTubeRmax,
798b4e0c 3484 kExternalTrayLen/2, 0, 360,
3485 0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
3486 0, 0, 1);
3487
96eb8210 3488 // The freon inside the forward tray tubes: a Tube
3489 TGeoCtub *freonTubeExt = new TGeoCtub(0, kCoolingTubeRmin,
3490 kExternalTrayLen/2, 0, 360,
3491 0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
3492 0, 0, 1);
3493
798b4e0c 3494 // The optical fibers inside the forward tray: a BBox
3495 TGeoBBox *optFibsForw = new TGeoBBox(kOpticalFibersSect/2,
3496 kOpticalFibersSect/2,
3497 kForwardTrayTotalLen/2);
3498
3499 // The optical fibers inside the external tray: a Xtru
3500 TGeoXtru *optFibsExt = new TGeoXtru(2);
3501 optFibsExt->SetName("ITSsuppSPDExtTrayOptFibs");
3502
3503 yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
3504 + 2*forwTrayWall->GetDY();
3505 xprof[0] = yprof[0]*TanD(kTrayAZRot);
3506 xprof[1] = kExternalTrayLen;
3507 yprof[1] = yprof[0];
3508 xprof[2] = xprof[1];
3509 yprof[2] = yprof[1] + kOpticalFibersSect;
3510 yprof[3] = yprof[2];
3511 xprof[3] = yprof[2]*TanD(kTrayAZRot);
3512
3513 optFibsExt->DefinePolygon(4, xprof, yprof);
3514 optFibsExt->DefineSection(0, 0);
3515 optFibsExt->DefineSection(1, kOpticalFibersSect);
3516
57126ea1 3517 // The Low Voltage cables inside the forward tray: two BBox
3518 TGeoBBox *lowCablesForwCu = new TGeoBBox(kLowVoltageCableSectCu,
3519 kLowVoltageCableSectCu/4,
3520 kForwardTrayTotalLen/2);
3521
3522 TGeoBBox *lowCablesForwPUR = new TGeoBBox(kLowVoltageCableSectCu,
3523 kLowVoltageCableHighPUR/4,
3524 kForwardTrayTotalLen/2);
798b4e0c 3525
57126ea1 3526 // The Low Voltage inside the external tray: two Xtru
3527 TGeoXtru *lowCablesExtCu = new TGeoXtru(2);
3528 lowCablesExtCu->SetName("ITSsuppSPDExtTrayLowVoltageCu");
798b4e0c 3529
3530 yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
3531 + 2*forwTrayWall->GetDY();
3532 xprof[0] = yprof[0]*TanD(kTrayAZRot);
3533 xprof[1] = kExternalTrayLen;
3534 yprof[1] = yprof[0];
3535 xprof[2] = xprof[1];
57126ea1 3536 yprof[2] = yprof[1] + kLowVoltageCableSectCu/2;
798b4e0c 3537 yprof[3] = yprof[2];
3538 xprof[3] = yprof[2]*TanD(kTrayAZRot);
3539
57126ea1 3540 lowCablesExtCu->DefinePolygon(4, xprof, yprof);
3541 lowCablesExtCu->DefineSection(0, 0);
3542 lowCablesExtCu->DefineSection(1, kLowVoltageCableSectCu*2);
798b4e0c 3543
57126ea1 3544 TGeoXtru *lowCablesExtPUR = new TGeoXtru(2);
3545 lowCablesExtPUR->SetName("ITSsuppSPDExtTrayLowVoltagePUR");
3546
3547 xprof[0] = lowCablesExtCu->GetX(3);
3548 yprof[0] = lowCablesExtCu->GetY(3);
3549 xprof[1] = lowCablesExtCu->GetX(2);
3550 yprof[1] = lowCablesExtCu->GetY(2);
3551 xprof[2] = xprof[1];
3552 yprof[2] = yprof[1] + kLowVoltageCableHighPUR/2;
3553 yprof[3] = yprof[2];
3554 xprof[3] = yprof[2]*TanD(kTrayAZRot);
3555
3556 lowCablesExtPUR->DefinePolygon(4, xprof, yprof);
3557 lowCablesExtPUR->DefineSection(0, 0);
3558 lowCablesExtPUR->DefineSection(1, kLowVoltageCableSectCu*2);
3559
3560 // The High Voltage cables inside the forward tray: two BBox
3561 TGeoBBox *hiCablesForwCu = new TGeoBBox(kHiVoltageCableSectCu,
3562 kHiVoltageCableSectCu/4,
3563 kForwardTrayTotalLen/2);
96eb8210 3564
57126ea1 3565 TGeoBBox *hiCablesForwPUR = new TGeoBBox(kHiVoltageCableSectCu,
3566 kHiVoltageCableHighPUR/4,
3567 kForwardTrayTotalLen/2);
3568
3569 // The High Voltage inside the external tray: two Xtru
3570 TGeoXtru *hiCablesExtCu = new TGeoXtru(2);
3571 hiCablesExtCu->SetName("ITSsuppSPDExtTrayHiVoltageCu");
96eb8210 3572
3573 yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
3574 + 2*forwTrayWall->GetDY();
3575 xprof[0] = yprof[0]*TanD(kTrayAZRot);
3576 xprof[1] = kExternalTrayLen;
3577 yprof[1] = yprof[0];
3578 xprof[2] = xprof[1];
57126ea1 3579 yprof[2] = yprof[1] + kHiVoltageCableSectCu/2;
3580 yprof[3] = yprof[2];
3581 xprof[3] = yprof[2]*TanD(kTrayAZRot);
3582
3583 hiCablesExtCu->DefinePolygon(4, xprof, yprof);
3584 hiCablesExtCu->DefineSection(0, 0);
3585 hiCablesExtCu->DefineSection(1, kHiVoltageCableSectCu*2);
3586
3587 TGeoXtru *hiCablesExtPUR = new TGeoXtru(2);
3588 hiCablesExtPUR->SetName("ITSsuppSPDExtTrayHiVoltagePUR");
3589
3590 xprof[0] = hiCablesExtCu->GetX(3);
3591 yprof[0] = hiCablesExtCu->GetY(3);
3592 xprof[1] = hiCablesExtCu->GetX(2);
3593 yprof[1] = hiCablesExtCu->GetY(2);
3594 xprof[2] = xprof[1];
3595 yprof[2] = yprof[1] + kHiVoltageCableHighPUR/2;
3596 yprof[3] = yprof[2];
3597 xprof[3] = yprof[2]*TanD(kTrayAZRot);
3598
3599 hiCablesExtPUR->DefinePolygon(4, xprof, yprof);
3600 hiCablesExtPUR->DefineSection(0, 0);
3601 hiCablesExtPUR->DefineSection(1, kHiVoltageCableSectCu*2);
3602
3603 // The Coaxial cables inside the forward tray: two BBox
3604 TGeoBBox *coaxCablesForwCu = new TGeoBBox(kCoaxCableSectCu,
3605 kCoaxCableSectCu/4,
3606 kForwardTrayTotalLen/2);
3607
3608 TGeoBBox *coaxCablesForwPUR = new TGeoBBox(kCoaxCableSectCu,
3609 kCoaxCableHighPUR/4,
3610 kForwardTrayTotalLen/2);
3611
3612 // The Coaxial inside the external tray: two Xtru
3613 TGeoXtru *coaxCablesExtCu = new TGeoXtru(2);
3614 coaxCablesExtCu->SetName("ITSsuppSPDExtTrayCoaxCu");
3615
3616 yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
3617 + 2*forwTrayWall->GetDY();
3618 xprof[0] = yprof[0]*TanD(kTrayAZRot);
3619 xprof[1] = kExternalTrayLen;
3620 yprof[1] = yprof[0];
3621 xprof[2] = xprof[1];
3622 yprof[2] = yprof[1] + kCoaxCableSectCu/2;
3623 yprof[3] = yprof[2];
3624 xprof[3] = yprof[2]*TanD(kTrayAZRot);
3625
3626 coaxCablesExtCu->DefinePolygon(4, xprof, yprof);
3627 coaxCablesExtCu->DefineSection(0, 0);
3628 coaxCablesExtCu->DefineSection(1, kCoaxCableSectCu*2);
3629
3630 TGeoXtru *coaxCablesExtPUR = new TGeoXtru(2);
3631 coaxCablesExtPUR->SetName("ITSsuppSPDExtTrayCoaxPUR");
3632
3633 xprof[0] = coaxCablesExtCu->GetX(3);
3634 yprof[0] = coaxCablesExtCu->GetY(3);
3635 xprof[1] = coaxCablesExtCu->GetX(2);
3636 yprof[1] = coaxCablesExtCu->GetY(2);
3637 xprof[2] = xprof[1];
3638 yprof[2] = yprof[1] + kCoaxCableHighPUR/2;
96eb8210 3639 yprof[3] = yprof[2];
3640 xprof[3] = yprof[2]*TanD(kTrayAZRot);
3641
57126ea1 3642 coaxCablesExtPUR->DefinePolygon(4, xprof, yprof);
3643 coaxCablesExtPUR->DefineSection(0, 0);
3644 coaxCablesExtPUR->DefineSection(1, kCoaxCableSectCu*2);
96eb8210 3645
798b4e0c 3646
3647 // We have all shapes: now create the real volumes
96eb8210 3648 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
3649 TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$");
3650 TGeoMedium *medFreon = mgr->GetMedium("ITS_GASEOUS FREON$");
3651 TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!TO BE CHECKED!
57126ea1 3652 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
3653 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
798b4e0c 3654
3655 TGeoVolume *forwTrayABase = new TGeoVolume("ITSsuppSPDSideAForwTrayABase",
3656 forwTrayLowerFace, medAl);
3657
3658 forwTrayABase->SetVisibility(kTRUE);
3659 forwTrayABase->SetLineColor(6); // Purple
3660 forwTrayABase->SetLineWidth(1);
3661 forwTrayABase->SetFillColor(forwTrayABase->GetLineColor());
3662 forwTrayABase->SetFillStyle(4000); // 0% transparent
3663
3664 TGeoVolume *forwTrayASide = new TGeoVolume("ITSsuppSPDSideAForwTrayASide",
3665 forwTraySideFace, medAl);
3666
3667 forwTrayASide->SetVisibility(kTRUE);
3668 forwTrayASide->SetLineColor(6); // Purple
3669 forwTrayASide->SetLineWidth(1);
3670 forwTrayASide->SetFillColor(forwTrayASide->GetLineColor());
3671 forwTrayASide->SetFillStyle(4000); // 0% transparent
3672
3673 TGeoVolume *forwTrayACoverShort = new TGeoVolume("ITSsuppSPDSideAForwTrayASC",
3674 forwTrayShortCover, medAl);
3675
3676 forwTrayACoverShort->SetVisibility(kTRUE);
3677 forwTrayACoverShort->SetLineColor(6); // Purple
3678 forwTrayACoverShort->SetLineWidth(1);
3679 forwTrayACoverShort->SetFillColor(forwTrayACoverShort->GetLineColor());
3680 forwTrayACoverShort->SetFillStyle(4000); // 0% transparent
3681
3682 TGeoVolume *forwTrayACoverLong = new TGeoVolume("ITSsuppSPDSideAForwTrayALC",
3683 forwTrayLongCover, medAl);
3684
3685 forwTrayACoverLong->SetVisibility(kTRUE);
3686 forwTrayACoverLong->SetLineColor(6); // Purple
3687 forwTrayACoverLong->SetLineWidth(1);
3688 forwTrayACoverLong->SetFillColor(forwTrayACoverLong->GetLineColor());
3689 forwTrayACoverLong->SetFillStyle(4000); // 0% transparent
3690
3691 TGeoVolume *forwTrayAWing = new TGeoVolume("ITSsuppSPDSideAForwTrayAWing",
3692 forwTrayWing, medAl);
3693
3694 forwTrayAWing->SetVisibility(kTRUE);
3695 forwTrayAWing->SetLineColor(6); // Purple
3696 forwTrayAWing->SetLineWidth(1);
3697 forwTrayAWing->SetFillColor(forwTrayAWing->GetLineColor());
3698 forwTrayAWing->SetFillStyle(4000); // 0% transparent
3699
3700 TGeoVolume *forwTrayAPlane = new TGeoVolume("ITSsuppSPDSideAForwTrayAPlane",
3701 forwTrayPlane, medAl);
3702
3703 forwTrayAPlane->SetVisibility(kTRUE);
3704 forwTrayAPlane->SetLineColor(6); // Purple
3705 forwTrayAPlane->SetLineWidth(1);
3706 forwTrayAPlane->SetFillColor(forwTrayAPlane->GetLineColor());
3707 forwTrayAPlane->SetFillStyle(4000); // 0% transparent
3708
3709 TGeoVolume *forwTrayAWall = new TGeoVolume("ITSsuppSPDSideAForwTrayAWall",
3710 forwTrayWall, medAl);
3711
3712 forwTrayAWall->SetVisibility(kTRUE);
3713 forwTrayAWall->SetLineColor(6); // Purple
3714 forwTrayAWall->SetLineWidth(1);
3715 forwTrayAWall->SetFillColor(forwTrayAWall->GetLineColor());
3716 forwTrayAWall->SetFillStyle(4000); // 0% transparent
3717
3718 TGeoVolume *extTrayAHorFace = new TGeoVolume("ITSsuppSPDSideAExtTrayHorFace",
3719 extTrayHorFace, medAl);
3720
3721 extTrayAHorFace->SetVisibility(kTRUE);
3722 extTrayAHorFace->SetLineColor(6); // Purple
3723 extTrayAHorFace->SetLineWidth(1);
3724 extTrayAHorFace->SetFillColor(extTrayAHorFace->GetLineColor());
3725 extTrayAHorFace->SetFillStyle(4000); // 0% transparent
3726
3727 TGeoVolume *extTrayAVerFace = new TGeoVolume("ITSsuppSPDSideAExtTrayVerFace",
3728 extTrayVerFace, medAl);
3729
3730 extTrayAVerFace->SetVisibility(kTRUE);
3731 extTrayAVerFace->SetLineColor(6); // Purple
3732 extTrayAVerFace->SetLineWidth(1);
3733 extTrayAVerFace->SetFillColor(extTrayAVerFace->GetLineColor());
3734 extTrayAVerFace->SetFillStyle(4000); // 0% transparent
3735
3736 TGeoVolume *extTrayAWall = new TGeoVolume("ITSsuppSPDSideAExtTrayWall",
3737 extTrayWall, medAl);
3738
3739 extTrayAWall->SetVisibility(kTRUE);
3740 extTrayAWall->SetLineColor(6); // Purple
3741 extTrayAWall->SetLineWidth(1);
3742 extTrayAWall->SetFillColor(extTrayAWall->GetLineColor());
3743 extTrayAWall->SetFillStyle(4000); // 0% transparent
3744
3745 TGeoVolume *forwCoolTube = new TGeoVolume("ITSsuppSPDSideAForwTrayCoolTube",
3746 coolTubeForw, medIn);
3747
3748 forwCoolTube->SetVisibility(kTRUE);
3749 forwCoolTube->SetLineColor(kGray); // as in GeometrySPD
3750 forwCoolTube->SetLineWidth(1);
3751 forwCoolTube->SetFillColor(forwCoolTube->GetLineColor());
3752 forwCoolTube->SetFillStyle(4000); // 0% transparent
3753
96eb8210 3754 TGeoVolume *forwCoolFreon = new TGeoVolume("ITSsuppSPDSideAForwTrayFreon",
3755 freonTubeForw, medFreon);
3756
3757 forwCoolFreon->SetVisibility(kTRUE);
3758 forwCoolFreon->SetLineColor(kBlue); // Blue
3759 forwCoolFreon->SetLineWidth(1);
3760 forwCoolFreon->SetFillColor(forwCoolFreon->GetLineColor());
3761 forwCoolFreon->SetFillStyle(4000); // 0% transparent
3762
798b4e0c 3763 TGeoVolume *extCoolTube = new TGeoVolume("ITSsuppSPDSideAExtTrayCoolTube",
3764 coolTubeExt, medIn);
3765
3766 extCoolTube->SetVisibility(kTRUE);
3767 extCoolTube->SetLineColor(kGray); // as in GeometrySPD
3768 extCoolTube->SetLineWidth(1);
3769 extCoolTube->SetFillColor(extCoolTube->GetLineColor());
3770 extCoolTube->SetFillStyle(4000); // 0% transparent
3771
96eb8210 3772 TGeoVolume *extCoolFreon = new TGeoVolume("ITSsuppSPDSideAExtTrayFreon",
3773 freonTubeExt, medFreon);
3774
3775 extCoolFreon->SetVisibility(kTRUE);
3776 extCoolFreon->SetLineColor(kBlue); // Blue
3777 extCoolFreon->SetLineWidth(1);
3778 extCoolFreon->SetFillColor(extCoolFreon->GetLineColor());
3779 extCoolFreon->SetFillStyle(4000); // 0% transparent
3780
798b4e0c 3781 TGeoVolume *forwOptFibs = new TGeoVolume("ITSsuppSPDSideAForwTrayOptFibs",
3782 optFibsForw, medFibs);
3783
3784 forwOptFibs->SetVisibility(kTRUE);
3785 forwOptFibs->SetLineColor(kOrange); // Orange
3786 forwOptFibs->SetLineWidth(1);
3787 forwOptFibs->SetFillColor(forwOptFibs->GetLineColor());
3788 forwOptFibs->SetFillStyle(4000); // 0% transparent
3789
3790 TGeoVolume *extOptFibs = new TGeoVolume("ITSsuppSPDSideAExtTrayOptFibs",
3791 optFibsExt, medFibs);
3792
3793 extOptFibs->SetVisibility(kTRUE);
3794 extOptFibs->SetLineColor(kOrange); // Orange
3795 extOptFibs->SetLineWidth(1);
3796 extOptFibs->SetFillColor(extOptFibs->GetLineColor());
3797 extOptFibs->SetFillStyle(4000); // 0% transparent
3798
57126ea1 3799 TGeoVolume *forwLowCabsCu = new TGeoVolume("ITSsuppSPDSideAForwLowCabsCu",
3800 lowCablesForwCu, medCu);
3801
3802 forwLowCabsCu->SetVisibility(kTRUE);
3803 forwLowCabsCu->SetLineColor(kRed); // Red
3804 forwLowCabsCu->SetLineWidth(1);
3805 forwLowCabsCu->SetFillColor(forwLowCabsCu->GetLineColor());
3806 forwLowCabsCu->SetFillStyle(4000); // 0% transparent
3807
3808 TGeoVolume *forwLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwLowCabsPUR",
3809 lowCablesForwPUR, medPUR);
3810
3811 forwLowCabsPUR->SetVisibility(kTRUE);
3812 forwLowCabsPUR->SetLineColor(kBlack); // Black
3813 forwLowCabsPUR->SetLineWidth(1);
3814 forwLowCabsPUR->SetFillColor(forwLowCabsPUR->GetLineColor());
3815 forwLowCabsPUR->SetFillStyle(4000); // 0% transparent
3816
3817 TGeoVolume *extLowCabsCu = new TGeoVolume("ITSsuppSPDSideAExtLowCabsCu",
3818 lowCablesExtCu, medCu);
3819
3820 extLowCabsCu->SetVisibility(kTRUE);
3821 extLowCabsCu->SetLineColor(kRed); // Red
3822 extLowCabsCu->SetLineWidth(1);
3823 extLowCabsCu->SetFillColor(extLowCabsCu->GetLineColor());
3824 extLowCabsCu->SetFillStyle(4000); // 0% transparent
3825
3826 TGeoVolume *extLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtLowCabsPUR",
3827 lowCablesExtPUR, medPUR);
3828
3829 extLowCabsPUR->SetVisibility(kTRUE);
3830 extLowCabsPUR->SetLineColor(kBlack); // Black
3831 extLowCabsPUR->SetLineWidth(1);
3832 extLowCabsPUR->SetFillColor(extLowCabsPUR->GetLineColor());
3833 extLowCabsPUR->SetFillStyle(4000); // 0% transparent
3834
3835 TGeoVolume *forwHiCabsCu = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsCu",
3836 hiCablesForwCu, medCu);
3837
3838 forwHiCabsCu->SetVisibility(kTRUE);
3839 forwHiCabsCu->SetLineColor(kRed); // Red
3840 forwHiCabsCu->SetLineWidth(1);
3841 forwHiCabsCu->SetFillColor(forwHiCabsCu->GetLineColor());
3842 forwHiCabsCu->SetFillStyle(4000); // 0% transparent
3843
3844 TGeoVolume *forwHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsPUR",
3845 hiCablesForwPUR, medPUR);
3846
3847 forwHiCabsPUR->SetVisibility(kTRUE);
3848 forwHiCabsPUR->SetLineColor(kBlack); // Black
3849 forwHiCabsPUR->SetLineWidth(1);
3850 forwHiCabsPUR->SetFillColor(forwHiCabsPUR->GetLineColor());
3851 forwHiCabsPUR->SetFillStyle(4000); // 0% transparent
3852
3853 TGeoVolume *extHiCabsCu = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsCu",
3854 hiCablesExtCu, medCu);
3855
3856 extHiCabsCu->SetVisibility(kTRUE);
3857 extHiCabsCu->SetLineColor(kRed); // Red
3858 extHiCabsCu->SetLineWidth(1);
3859 extHiCabsCu->SetFillColor(extHiCabsCu->GetLineColor());
3860 extHiCabsCu->SetFillStyle(4000); // 0% transparent
3861
3862 TGeoVolume *extHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsPUR",
3863 hiCablesExtPUR, medPUR);
3864
3865 extHiCabsPUR->SetVisibility(kTRUE);
3866 extHiCabsPUR->SetLineColor(kBlack); // Black
3867 extHiCabsPUR->SetLineWidth(1);
3868 extHiCabsPUR->SetFillColor(extHiCabsPUR->GetLineColor());
3869 extHiCabsPUR->SetFillStyle(4000); // 0% transparent
3870
3871 TGeoVolume *forwCoaxCu = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxCu",
3872 coaxCablesForwCu, medCu);
3873
3874 forwCoaxCu->SetVisibility(kTRUE);
3875 forwCoaxCu->SetLineColor(kRed); // Red
3876 forwCoaxCu->SetLineWidth(1);
3877 forwCoaxCu->SetFillColor(forwCoaxCu->GetLineColor());
3878 forwCoaxCu->SetFillStyle(4000); // 0% transparent
3879
3880 TGeoVolume *forwCoaxPUR = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxPUR",
3881 coaxCablesForwPUR, medPUR);
3882
3883 forwCoaxPUR->SetVisibility(kTRUE);
3884 forwCoaxPUR->SetLineColor(kBlack); // Black
3885 forwCoaxPUR->SetLineWidth(1);
3886 forwCoaxPUR->SetFillColor(forwCoaxPUR->GetLineColor());
3887 forwCoaxPUR->SetFillStyle(4000); // 0% transparent
3888
3889 TGeoVolume *extCoaxCu = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxCu",
3890 coaxCablesExtCu, medCu);
3891
3892 extCoaxCu->SetVisibility(kTRUE);
3893 extCoaxCu->SetLineColor(kRed); // Red
3894 extCoaxCu->SetLineWidth(1);
3895 extCoaxCu->SetFillColor(extCoaxCu->GetLineColor());
3896 extCoaxCu->SetFillStyle(4000); // 0% transparent
3897
3898 TGeoVolume *extCoaxPUR = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxPUR",
3899 coaxCablesExtPUR, medPUR);
3900
3901 extCoaxPUR->SetVisibility(kTRUE);
3902 extCoaxPUR->SetLineColor(kBlack); // Black
3903 extCoaxPUR->SetLineWidth(1);
3904 extCoaxPUR->SetFillColor(extCoaxPUR->GetLineColor());
3905 extCoaxPUR->SetFillStyle(4000); // 0% transparent
96eb8210 3906
798b4e0c 3907
3908 // Now build up the trays
3909 yloc = forwTrayLowerFace->GetDY();
3910 zloc = forwTrayLowerFace->GetDZ();
3911 cableTrayAForw->AddNode(forwTrayABase, 1,
3912 new TGeoTranslation(0, yloc, zloc));
3913
3914 xloc = kForwardTrayWide/2;
3915 cableTrayAForw->AddNode(forwTrayASide, 1,
3916 new TGeoCombiTrans( xloc, 0, 0,
3917 new TGeoRotation("",90,-90,-90)));
3918 cableTrayAForw->AddNode(forwTrayASide, 2,
3919 new TGeoCombiTrans(-xloc+kForwardTrayThick, 0, 0,
3920 new TGeoRotation("",90,-90,-90)));
3921
3922 yloc = kForwardTrayFirstHigh - forwTrayShortCover->GetDY();
3923 zloc = forwTrayShortCover->GetDZ();
3924 cableTrayAForw->AddNode(forwTrayACoverShort, 1,
3925 new TGeoTranslation(0, yloc, zloc));
3926
3927 yloc = kForwardTraySecondHigh - forwTrayLongCover->GetDY();
3928 zloc = kForwardTrayFirstLen + forwTrayLongCover->GetDZ();
3929 cableTrayAForw->AddNode(forwTrayACoverLong, 1,
3930 new TGeoTranslation(0, yloc, zloc));
3931
3932 xloc = kForwardTrayWide/2 - kForwardTrayThick - forwTrayWing->GetDX();
3933 yloc = kForwardTrayFirstHigh - kForwardTrayThick - forwTrayWing->GetDY();
3934 zloc = kForwardTrayFirstLen - forwTrayWing->GetDZ();
3935 cableTrayAForw->AddNode(forwTrayAWing, 1,
3936 new TGeoTranslation( xloc, yloc, zloc));
3937 cableTrayAForw->AddNode(forwTrayAWing, 2,
3938 new TGeoTranslation(-xloc, yloc, zloc));
3939
3940 yloc = kForwardTrayThick + kForwardTrayInterSpace - forwTrayPlane->GetDY();
3941 zloc = forwTrayPlane->GetDZ();
3942 cableTrayAForw->AddNode(forwTrayAPlane, 1,
3943 new TGeoTranslation(0, yloc, zloc));
3944
3945 yloc = kForwardTrayThick + forwTrayWall->GetDY();
3946 zloc = forwTrayWall->GetDZ();
3947 cableTrayAForw->AddNode(forwTrayAWall, 1,
3948 new TGeoTranslation(0, yloc, zloc));
3949
96eb8210 3950 forwCoolTube->AddNode(forwCoolFreon, 1, 0);
3951
798b4e0c 3952 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY()
3953 + coolTubeForw->GetRmax();
3954 zloc = coolTubeForw->GetDz();
3955 cableTrayAForw->AddNode(forwCoolTube, 1,
3956 new TGeoTranslation(0, yloc, zloc));
3957
3958 xloc = optFibsForw->GetDX() + coolTubeForw->GetRmax();
3959 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() + optFibsForw->GetDY();
3960 zloc = optFibsForw->GetDZ();
3961 cableTrayAForw->AddNode(forwOptFibs, 1,
3962 new TGeoTranslation(xloc, yloc, zloc));
3963
57126ea1 3964 xloc = lowCablesForwCu->GetDX() + coolTubeForw->GetRmax();
3965 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() +
3966 lowCablesForwCu->GetDY();
3967 zloc = lowCablesForwCu->GetDZ();
3968 cableTrayAForw->AddNode(forwLowCabsCu, 1,
3969 new TGeoTranslation(-xloc, yloc, zloc));
3970 yloc += lowCablesForwCu->GetDY()+ lowCablesForwPUR->GetDY();
3971 cableTrayAForw->AddNode(forwLowCabsPUR, 1,
798b4e0c 3972 new TGeoTranslation(-xloc, yloc, zloc));
3973
57126ea1 3974 xloc = hiCablesForwCu->GetDX() + 2*lowCablesForwCu->GetDX()
96eb8210 3975 + coolTubeForw->GetRmax();
57126ea1 3976 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() +
3977 hiCablesForwCu->GetDY();
3978 zloc = hiCablesForwCu->GetDZ();
3979 cableTrayAForw->AddNode(forwHiCabsCu, 1,
3980 new TGeoTranslation(-xloc, yloc, zloc));
3981 yloc += hiCablesForwCu->GetDY()+ hiCablesForwPUR->GetDY();
3982 cableTrayAForw->AddNode(forwHiCabsPUR, 1,
96eb8210 3983 new TGeoTranslation(-xloc, yloc, zloc));
3984
57126ea1 3985 xloc = coaxCablesForwCu->GetDX() + 2*optFibsForw->GetDX() +
3986 coolTubeForw->GetRmax();
3987 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY() +
3988 coaxCablesForwCu->GetDY();
3989 zloc = coaxCablesForwCu->GetDZ();
3990 cableTrayAForw->AddNode(forwCoaxCu, 1,
3991 new TGeoTranslation( xloc, yloc, zloc));
3992 yloc += coaxCablesForwCu->GetDY()+ coaxCablesForwPUR->GetDY();
3993 cableTrayAForw->AddNode(forwCoaxPUR, 1,
3994 new TGeoTranslation( xloc, yloc, zloc));
3995
798b4e0c 3996 // To simplify following placement in MARS, origin is on top
3997 yloc = -kExternalTrayHigh + kExternalTrayThick/2;
3998 zloc = kExternalTrayLen/2;
3999 cableTrayAExt->AddNode(extTrayAHorFace, 1,
4000 new TGeoTranslation( 0, yloc, zloc));
4001
4002 xloc = kExternalTrayWide/2 - kExternalTrayThick/2;
4003 yloc = -kExternalTrayHigh/2;
4004 cableTrayAExt->AddNode(extTrayAVerFace, 1,
4005 new TGeoTranslation( xloc, yloc, zloc));
4006 cableTrayAExt->AddNode(extTrayAVerFace, 2,
4007 new TGeoTranslation(-xloc, yloc, zloc));
4008
4009 yloc = -kExternalTrayThick/2;
4010 cableTrayAExt->AddNode(extTrayAHorFace, 2,
4011 new TGeoTranslation( 0, yloc, zloc));
4012
4013 yloc = -kExternalTrayHigh
4014 + kExternalTrayThick + kForwardTrayInterSpace - kExternalTrayThick/2;
4015 cableTrayAExt->AddNode(extTrayAHorFace, 3,
4016 new TGeoTranslation( 0, yloc, zloc));
4017
4018 yloc = -kExternalTrayHigh + kExternalTrayThick + extTrayWall->GetDY();
4019 cableTrayAExt->AddNode(extTrayAWall, 1,
4020 new TGeoTranslation( 0, yloc, zloc));
4021
96eb8210 4022 extCoolTube->AddNode(extCoolFreon, 1, 0);
4023
798b4e0c 4024 yloc = -kExternalTrayHigh + 2*kExternalTrayThick + 2*extTrayWall->GetDY()
4025 + coolTubeExt->GetRmax();
4026 zloc = coolTubeExt->GetDz();
4027 cableTrayAExt->AddNode(extCoolTube, 1,
4028 new TGeoTranslation(0, yloc, zloc));
4029
57126ea1 4030 xloc = optFibsExt->GetZ(1) + coolTubeExt->GetRmax();
798b4e0c 4031 cableTrayAExt->AddNode(extOptFibs, 1,
4032 new TGeoCombiTrans( xloc, 0, 0,
4033 new TGeoRotation("",90,-90,-90)));
4034
57126ea1 4035 xloc = coolTubeExt->GetRmax();
4036 cableTrayAExt->AddNode(extLowCabsCu, 1,
4037 new TGeoCombiTrans(-xloc, 0, 0,
4038 new TGeoRotation("",90,-90,-90)));
4039 cableTrayAExt->AddNode(extLowCabsPUR, 1,
798b4e0c 4040 new TGeoCombiTrans(-xloc, 0, 0,
4041 new TGeoRotation("",90,-90,-90)));
4042
57126ea1 4043 xloc = lowCablesExtCu->GetZ(1) + coolTubeExt->GetRmax();
4044 cableTrayAExt->AddNode(extHiCabsCu, 1,
4045 new TGeoCombiTrans(-xloc, 0, 0,
4046 new TGeoRotation("",90,-90,-90)));
4047 cableTrayAExt->AddNode(extHiCabsPUR, 1,
96eb8210 4048 new TGeoCombiTrans(-xloc, 0, 0,
4049 new TGeoRotation("",90,-90,-90)));
4050
57126ea1 4051 xloc = coaxCablesExtCu->GetZ(1) + optFibsExt->GetZ(1) +
4052 coolTubeExt->GetRmax();
4053 cableTrayAExt->AddNode(extCoaxCu, 1,
4054 new TGeoCombiTrans( xloc, 0, 0,
4055 new TGeoRotation("",90,-90,-90)));
4056 cableTrayAExt->AddNode(extCoaxPUR, 1,
4057 new TGeoCombiTrans( xloc, 0, 0,
4058 new TGeoRotation("",90,-90,-90)));
4059
798b4e0c 4060
4061 // Finally put everything in the mother volume
4062 Double_t rExtTray = kTrayAR2Trans + kExternalTrayHigh;
4063
4064 moth->AddNode(cableTrayAForw,1,
4065 new TGeoTranslation( 0, kTrayAR1Trans, kTrayAZTrans));
4066 moth->AddNode(cableTrayAForw,2,
4067 new TGeoCombiTrans( 0,-kTrayAR1Trans, kTrayAZTrans,
4068 new TGeoRotation("",180, 0, 0)));
4069
4070 yloc = kTrayAR1Trans + kExternalTrayHigh;
4071 zloc = kTrayAZTrans + kForwardTrayTotalLen;
4072 moth->AddNode(cableTrayAExt,1,
4073 new TGeoCombiTrans( 0, yloc, zloc,
4074 new TGeoRotation("", 0,-kTrayAZRot, 0)));
4075 moth->AddNode(cableTrayAExt,2,
4076 new TGeoCombiTrans( 0,-yloc, zloc,
4077 new TGeoRotation("",180,-kTrayAZRot, 0)));
4078
4079 alpharot = kTrayAFirstRotAng + kTrayASecondRotAng;
4080 xloc = kTrayAR2Trans*SinD(alpharot);
4081 yloc = kTrayAR2Trans*CosD(alpharot);
4082 moth->AddNode(cableTrayAForw,3,
4083 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4084 new TGeoRotation("",-alpharot,0,0) ) );
4085 xloc = rExtTray*SinD(alpharot);
4086 yloc = rExtTray*CosD(alpharot);
4087 moth->AddNode(cableTrayAExt,3,
4088 new TGeoCombiTrans( xloc, yloc, zloc,
4089 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4090
4091 alpharot += 180;
4092 xloc = kTrayAR2Trans*SinD(alpharot);
4093 yloc = kTrayAR2Trans*CosD(alpharot);
4094 moth->AddNode(cableTrayAForw,4,
4095 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4096 new TGeoRotation("",-alpharot,0,0) ) );
4097 xloc = rExtTray*SinD(alpharot);
4098 yloc = rExtTray*CosD(alpharot);
4099 moth->AddNode(cableTrayAExt,4,
4100 new TGeoCombiTrans( xloc, yloc, zloc,
4101 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4102
4103 alpharot = - kTrayAFirstRotAng - kTrayASecondRotAng;
4104 xloc = kTrayAR2Trans*SinD(alpharot);
4105 yloc = kTrayAR2Trans*CosD(alpharot);
4106 moth->AddNode(cableTrayAForw,5,
4107 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4108 new TGeoRotation("",-alpharot,0,0) ) );
4109 xloc = rExtTray*SinD(alpharot);
4110 yloc = rExtTray*CosD(alpharot);
4111 moth->AddNode(cableTrayAExt,5,
4112 new TGeoCombiTrans( xloc, yloc, zloc,
4113 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4114
4115 alpharot += 180;
4116 xloc = kTrayAR2Trans*SinD(alpharot);
4117 yloc = kTrayAR2Trans*CosD(alpharot);
4118 moth->AddNode(cableTrayAForw,6,
4119 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4120 new TGeoRotation("",-alpharot,0,0) ) );
4121 xloc = rExtTray*SinD(alpharot);
4122 yloc = rExtTray*CosD(alpharot);
4123 moth->AddNode(cableTrayAExt,6,
4124 new TGeoCombiTrans( xloc, yloc, zloc,
4125 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4126
4127 alpharot = kTrayAFirstRotAng + 3*kTrayASecondRotAng;
4128 xloc = kTrayAR2Trans*SinD(alpharot);
4129 yloc = kTrayAR2Trans*CosD(alpharot);
4130 moth->AddNode(cableTrayAForw,7,
4131 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4132 new TGeoRotation("",-alpharot,0,0) ) );
4133 xloc = rExtTray*SinD(alpharot);
4134 yloc = rExtTray*CosD(alpharot);
4135 moth->AddNode(cableTrayAExt,7,
4136 new TGeoCombiTrans( xloc, yloc, zloc,
4137 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4138
4139 alpharot += 180;
4140 xloc = kTrayAR2Trans*SinD(alpharot);
4141 yloc = kTrayAR2Trans*CosD(alpharot);
4142 moth->AddNode(cableTrayAForw,8,
4143 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4144 new TGeoRotation("",-alpharot,0,0) ) );
4145 xloc = rExtTray*SinD(alpharot);
4146 yloc = rExtTray*CosD(alpharot);
4147 moth->AddNode(cableTrayAExt,8,
4148 new TGeoCombiTrans( xloc, yloc, zloc,
4149 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4150
4151 alpharot = - kTrayAFirstRotAng - 3*kTrayASecondRotAng;
4152 xloc = kTrayAR2Trans*SinD(alpharot);
4153 yloc = kTrayAR2Trans*CosD(alpharot);
4154 moth->AddNode(cableTrayAForw,9,
4155 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4156 new TGeoRotation("",-alpharot,0,0) ) );
4157 xloc = rExtTray*SinD(alpharot);
4158 yloc = rExtTray*CosD(alpharot);
4159 moth->AddNode(cableTrayAExt,9,
4160 new TGeoCombiTrans( xloc, yloc, zloc,
4161 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4162
4163 alpharot += 180;
4164 xloc = kTrayAR2Trans*SinD(alpharot);
4165 yloc = kTrayAR2Trans*CosD(alpharot);
4166 moth->AddNode(cableTrayAForw,10,
4167 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4168 new TGeoRotation("",-alpharot,0,0) ) );
4169 xloc = rExtTray*SinD(alpharot);
4170 yloc = rExtTray*CosD(alpharot);
4171 moth->AddNode(cableTrayAExt,10,
4172 new TGeoCombiTrans( xloc, yloc, zloc,
4173 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4174
4175
4176 return;
4177}
4178
aa177c73 4179//______________________________________________________________________
4180void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
4181 TGeoManager *mgr){
4182//
4183// Creates the SPD cable trays which are outside the ITS support cones
4184// but still inside the TPC on Side C
4185// (part of this code is taken or anyway inspired to ServicesCableSupport
4186// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
4187//
4188// Input:
4189// moth : the TGeoVolume owing the volume structure
4190// mgr : the GeoManager (default gGeoManager)
4191// Output:
4192//
4193// Return:
4194//
4195// Created: ??? Bjorn S. Nilsen
4196// Updated: 22 Apr 2010 Mario Sitta
96eb8210 4197// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes
57126ea1 4198// Updated: 08 Sep 2010 Mario Sitta
aa177c73 4199//
4200// Technical data are taken from AutoCAD drawings and other (oral)
4201// information given by D.Elia
57126ea1 4202// Optical fibers and voltage cables are approximated with mean materials
4203// and square cross sections, but preserving the total material budget.
aa177c73 4204//
4205
4206 // Dimensions and positions of the C-Side Cable Tray elements
4207 const Int_t kNumTraysSideC = 10;
4208
4209 const Double_t kTrayCHalfWide = 6.350 *fgkcm;
4210 const Double_t kTrayCLength1 = 172.800 *fgkcm;
4211 const Double_t kTrayCLength2 = 189.300 *fgkcm;
4212 const Double_t kTrayCFirstLen = 435.000 *fgkmm;
4213 const Double_t kTrayCFirstHigh = 83.000 *fgkmm;//!!!TO BE CHECKED!!!
4214 const Double_t kTrayCSecondHigh = 52.700 *fgkmm;//!!!TO BE CHECKED!!!
4215 const Double_t kTrayCThick = 0.200 *fgkcm;
4216 const Double_t kTrayCInterSpace = 18.000 *fgkmm;//!!!TO BE CHECKED!!!
4217 const Double_t kTrayCFoldAngle = 5.000 *fgkDegree;
4218
57126ea1 4219 const Double_t kCoolingTubeRmin = 2.000 *fgkmm;
4220 const Double_t kCoolingTubeRmax = 3.000 *fgkmm;
aa177c73 4221 const Double_t kOpticalFibersSect = 8.696 *fgkmm;//!!!ESTIMATED!!!
57126ea1 4222 const Double_t kLowVoltCableSectCu = 7.675 *fgkmm;// Computed
4223 const Double_t kLowVoltCableHighPUR = 1.000 *fgkmm;// Computed
4224 const Double_t kHiVoltCableSectCu = 1.535 *fgkmm;// Computed
4225 const Double_t kHiVoltCableHighPUR = 0.500 *fgkmm;// Computed
4226 const Double_t kCoaxCableSectCu = 6.140 *fgkmm;//!!!ESTIMATED!!!
4227 const Double_t kCoaxCableHighPUR = 1.000 *fgkmm;//!!!ESTIMATED!!!
aa177c73 4228
4229 // Overall position and rotation of the C-Side Cable Trays
4230 const Double_t kTraySideCRPos = 45.300 *fgkcm;
4231 const Double_t kTraySideCZPos = -102.400 *fgkcm;
4232 const Double_t kTraySideCAlphaRot[kNumTraysSideC/2] =
4233 { 0.0, 41.0, -41.0, 76.0, -76.0};
4234 // From position of the other trays
4235
4236
4237 // Local variables
4238 Double_t xprof[8], yprof[8];
4239 Double_t xloc, yloc, zloc, delta, alpharot;
4240
4241
4242 // The single C-Side Cable tray as an assembly
4243 TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly("ITSsupportSPDTrayC");
4244
4245 // First create all needed shapes
4246
4247 // The Cable Tray lower face: a Xtru
4248 TGeoXtru *sideCHorFace = new TGeoXtru(2);
4249
4250 xprof[0] = 0.;
4251 yprof[0] = 0.;
4252 xprof[1] = kTrayCLength1;
4253 yprof[1] = 0.;
4254 xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
4255 yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
4256 xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle);
4257 yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle);
4258 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4259 kTrayCThick , xprof[4], yprof[4]);
4260 xprof[5] = 0.;
4261 yprof[5] = kTrayCThick;
4262
4263 delta = kTrayCHalfWide - kTrayCThick;
4264
4265 sideCHorFace->DefinePolygon(6, xprof, yprof);
4266 sideCHorFace->DefineSection(0,-delta);
4267 sideCHorFace->DefineSection(1, delta);
4268
4269 // The Cable Tray middle face: a Xtru
4270 // (somehow duplicate of HorFace, but in this way avoid an overlap with Wall)
4271 TGeoXtru *sideCMidFace = new TGeoXtru(2);
4272
4273 xprof[0] = 0.;
4274 yprof[0] = kTrayCInterSpace + kTrayCThick;
4275 xprof[1] = kTrayCLength1;
4276 yprof[1] = yprof[0];
4277 xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
4278 yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
4279 xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle);
4280 yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle);
4281 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4282 kTrayCThick , xprof[4], yprof[4]);
4283 xprof[5] = 0.;
4284 yprof[5] = yprof[0] + kTrayCThick;
4285
4286 delta = kTrayCHalfWide - kTrayCThick;
4287
4288 sideCMidFace->DefinePolygon(6, xprof, yprof);
4289 sideCMidFace->DefineSection(0,-delta);
4290 sideCMidFace->DefineSection(1, delta);
4291
4292 // The Cable Tray lower face: a Xtru
4293 TGeoXtru *sideCSideFace = new TGeoXtru(2);
4294
4295 xprof[0] = 0.;
4296 yprof[0] = 0.;
4297 xprof[1] = kTrayCLength1;
4298 yprof[1] = 0.;
4299 xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
4300 yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
4301 xprof[3] = xprof[2] - kTrayCSecondHigh*SinD(kTrayCFoldAngle);
4302 yprof[3] = yprof[2] + kTrayCSecondHigh*CosD(kTrayCFoldAngle);
4303 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4304 kTrayCSecondHigh , xprof[4], yprof[4]);
4305 xprof[5] = kTrayCFirstLen;
4306 yprof[5] = kTrayCSecondHigh;
4307 xprof[6] = xprof[5];
4308 yprof[6] = kTrayCFirstHigh;
4309 xprof[7] = xprof[0];
4310 yprof[7] = yprof[6];
4311
4312 sideCSideFace->DefinePolygon(8, xprof, yprof);
4313 sideCSideFace->DefineSection(0, 0);
4314 sideCSideFace->DefineSection(1, kTrayCThick);
4315
4316 // The short cover: a BBox
4317 TGeoBBox *sideCShortCover = new TGeoBBox(kTrayCFirstLen/2,
4318 kTrayCThick/2,
4319 kTrayCHalfWide-kTrayCThick);
4320
4321 // The long cover: a Xtru
4322 TGeoXtru *sideCLongCover = new TGeoXtru(2);
4323
4324 xprof[5] = sideCSideFace->GetX(5);
4325 yprof[5] = sideCSideFace->GetY(5);
4326 xprof[4] = sideCSideFace->GetX(4);
4327 yprof[4] = sideCSideFace->GetY(4);
4328 xprof[3] = sideCSideFace->GetX(3);
4329 yprof[3] = sideCSideFace->GetY(3);
4330 xprof[2] = xprof[3] + kTrayCThick*SinD(kTrayCFoldAngle);
4331 yprof[2] = yprof[3] - kTrayCThick*CosD(kTrayCFoldAngle);
4332 InsidePoint(xprof[5], yprof[5], xprof[4], yprof[4], xprof[3], yprof[3],
4333 -kTrayCThick , xprof[1], yprof[1]);
4334 xprof[0] = xprof[5];
4335 yprof[0] = yprof[5] - kTrayCThick;
4336
4337 delta = kTrayCHalfWide - kTrayCThick;
4338
4339 sideCLongCover->DefinePolygon(6, xprof, yprof);
4340 sideCLongCover->DefineSection(0,-delta);
4341 sideCLongCover->DefineSection(1, delta);
4342
4343 // The internal wall: a Xtru
4344 TGeoXtru *intWall = new TGeoXtru(2);
4345
4346 xprof[0] = sideCHorFace->GetX(5);
4347 yprof[0] = sideCHorFace->GetY(5);
4348 xprof[1] = sideCHorFace->GetX(4);
4349 yprof[1] = sideCHorFace->GetY(4);
4350 xprof[2] = sideCHorFace->GetX(3);
4351 yprof[2] = sideCHorFace->GetY(3);
4352 xprof[3] = sideCMidFace->GetX(2);
4353 yprof[3] = sideCMidFace->GetY(2);
4354 xprof[4] = sideCMidFace->GetX(1);
4355 yprof[4] = sideCMidFace->GetY(1);
4356 xprof[5] = sideCMidFace->GetX(0);
4357 yprof[5] = sideCMidFace->GetY(0);
4358
4359 intWall->DefinePolygon(6, xprof, yprof);
4360 intWall->DefineSection(0,-kTrayCThick/2);
4361 intWall->DefineSection(1, kTrayCThick/2);
4362
4363 // The horizontal part of the cooling tube inside the tray: a Tube
4364 delta = sideCMidFace->GetX(4) - sideCMidFace->GetX(5);
96eb8210 4365 TGeoTube *horTube = new TGeoTube(0, kCoolingTubeRmax, delta/2);
4366
4367 // The freon inside the horizontal part of the cooling tube: a Tube
4368 TGeoTube *horFreon = new TGeoTube(0, kCoolingTubeRmin, delta/2);
aa177c73 4369
4370 // The inclined part of the cooling tube inside the tray: a Ctub
4371 Double_t x3, y3, x4, y4;
4372 x3 = sideCMidFace->GetX(3);
4373 y3 = sideCMidFace->GetY(3);
4374 x4 = sideCMidFace->GetX(4);
4375 y4 = sideCMidFace->GetY(4);
4376 delta = TMath::Sqrt( (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
4377 (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle)) +
4378 (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
4379 (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle)) );
4380
96eb8210 4381 TGeoCtub *incTube = new TGeoCtub(0, kCoolingTubeRmax, delta/2, 0, 360,
4382 0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
4383 0, 0, 1);
4384
4385 // The freon inside the inclined part of the cooling tube: a Ctub
4386 TGeoCtub *incFreon = new TGeoCtub(0, kCoolingTubeRmin, delta/2, 0, 360,
aa177c73 4387 0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
4388 0, 0, 1);
4389
4390 // The optical fibers inside the tray: a Xtru
4391 TGeoXtru *optFibs = new TGeoXtru(2);
4392
4393 xprof[0] = sideCMidFace->GetX(5);
aa177c73 4394 yprof[0] = sideCMidFace->GetY(5);
4395 xprof[1] = sideCMidFace->GetX(4);
4396 yprof[1] = sideCMidFace->GetY(4);
4397 xprof[2] = sideCMidFace->GetX(3);
4398 yprof[2] = sideCMidFace->GetY(3);
4399 xprof[3] = xprof[2] - kOpticalFibersSect*SinD(kTrayCFoldAngle);
4400 yprof[3] = yprof[2] + kOpticalFibersSect*CosD(kTrayCFoldAngle);
4401 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4402 kOpticalFibersSect , xprof[4], yprof[4]);
4403 xprof[5] = 0.;
4404 yprof[5] = yprof[0] + kOpticalFibersSect;
4405
4406 optFibs->DefinePolygon(6, xprof, yprof);
4407 optFibs->DefineSection(0, 0);
4408 optFibs->DefineSection(1, kOpticalFibersSect);
4409
57126ea1 4410 // The low voltage cables inside the tray: two Xtru
4411 TGeoXtru *lowCablesCu = new TGeoXtru(2);
4412
4413 xprof[0] = sideCMidFace->GetX(5);
4414 yprof[0] = sideCMidFace->GetY(5);
4415 xprof[1] = sideCMidFace->GetX(4);
4416 yprof[1] = sideCMidFace->GetY(4);
4417 xprof[2] = sideCMidFace->GetX(3);
4418 yprof[2] = sideCMidFace->GetY(3);
4419 xprof[3] = xprof[2] - kLowVoltCableSectCu*SinD(kTrayCFoldAngle);
4420 yprof[3] = yprof[2] + kLowVoltCableSectCu*CosD(kTrayCFoldAngle);
4421 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4422 kLowVoltCableSectCu , xprof[4], yprof[4]);
4423 xprof[5] = 0.;
4424 yprof[5] = yprof[0] + kLowVoltCableSectCu;
4425
4426 lowCablesCu->DefinePolygon(6, xprof, yprof);
4427 lowCablesCu->DefineSection(0, 0);
4428 lowCablesCu->DefineSection(1, kLowVoltCableSectCu);
4429
4430 TGeoXtru *lowCablesPUR = new TGeoXtru(2);
4431
4432 xprof[0] = lowCablesCu->GetX(5);
4433 yprof[0] = lowCablesCu->GetY(5);
4434 xprof[1] = lowCablesCu->GetX(4);
4435 yprof[1] = lowCablesCu->GetY(4);
4436 xprof[2] = lowCablesCu->GetX(3);
4437 yprof[2] = lowCablesCu->GetY(3);
4438 xprof[3] = xprof[2] - kLowVoltCableHighPUR*SinD(kTrayCFoldAngle);
4439 yprof[3] = yprof[2] + kLowVoltCableHighPUR*CosD(kTrayCFoldAngle);
4440 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4441 kLowVoltCableHighPUR , xprof[4], yprof[4]);
4442 xprof[5] = 0.;
4443 yprof[5] = yprof[0] + kLowVoltCableHighPUR;
4444
4445 lowCablesPUR->DefinePolygon(6, xprof, yprof);
4446 lowCablesPUR->DefineSection(0, 0);
4447 lowCablesPUR->DefineSection(1, kLowVoltCableSectCu);
4448
4449 // The high voltage cables inside the tray: two Xtru
4450 TGeoXtru *hiCablesCu = new TGeoXtru(2);
aa177c73 4451
4452 xprof[0] = sideCMidFace->GetX(5);
4453 yprof[0] = sideCMidFace->GetY(5);
4454 xprof[1] = sideCMidFace->GetX(4);
4455 yprof[1] = sideCMidFace->GetY(4);
4456 xprof[2] = sideCMidFace->GetX(3);
4457 yprof[2] = sideCMidFace->GetY(3);
57126ea1 4458 xprof[3] = xprof[2] - kHiVoltCableSectCu*SinD(kTrayCFoldAngle);
4459 yprof[3] = yprof[2] + kHiVoltCableSectCu*CosD(kTrayCFoldAngle);
aa177c73 4460 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
57126ea1 4461 kHiVoltCableSectCu , xprof[4], yprof[4]);
aa177c73 4462 xprof[5] = 0.;
57126ea1 4463 yprof[5] = yprof[0] + kHiVoltCableSectCu;
4464
4465 hiCablesCu->DefinePolygon(6, xprof, yprof);
4466 hiCablesCu->DefineSection(0, 0);
4467 hiCablesCu->DefineSection(1, kHiVoltCableSectCu);
4468
4469 TGeoXtru *hiCablesPUR = new TGeoXtru(2);
4470
4471 xprof[0] = hiCablesCu->GetX(5);
4472 yprof[0] = hiCablesCu->GetY(5);
4473 xprof[1] = hiCablesCu->GetX(4);
4474 yprof[1] = hiCablesCu->GetY(4);
4475 xprof[2] = hiCablesCu->GetX(3);
4476 yprof[2] = hiCablesCu->GetY(3);
4477 xprof[3] = xprof[2] - kHiVoltCableHighPUR*SinD(kTrayCFoldAngle);
4478 yprof[3] = yprof[2] + kHiVoltCableHighPUR*CosD(kTrayCFoldAngle);
4479 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4480 kHiVoltCableHighPUR , xprof[4], yprof[4]);
4481 xprof[5] = 0.;
4482 yprof[5] = yprof[0] + kHiVoltCableHighPUR;
aa177c73 4483
57126ea1 4484 hiCablesPUR->DefinePolygon(6, xprof, yprof);
4485 hiCablesPUR->DefineSection(0, 0);
4486 hiCablesPUR->DefineSection(1, kHiVoltCableSectCu);
aa177c73 4487
57126ea1 4488 // The coaxial cables inside the tray: two Xtru
4489 TGeoXtru *coaxCablesCu = new TGeoXtru(2);
96eb8210 4490
4491 xprof[0] = sideCMidFace->GetX(5);
4492 yprof[0] = sideCMidFace->GetY(5);
4493 xprof[1] = sideCMidFace->GetX(4);
4494 yprof[1] = sideCMidFace->GetY(4);
4495 xprof[2] = sideCMidFace->GetX(3);
4496 yprof[2] = sideCMidFace->GetY(3);
57126ea1 4497 xprof[3] = xprof[2] - kCoaxCableSectCu*SinD(kTrayCFoldAngle);
4498 yprof[3] = yprof[2] + kCoaxCableSectCu*CosD(kTrayCFoldAngle);
96eb8210 4499 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
57126ea1 4500 kCoaxCableSectCu , xprof[4], yprof[4]);
96eb8210 4501 xprof[5] = 0.;
57126ea1 4502 yprof[5] = yprof[0] + kCoaxCableSectCu;
4503
4504 coaxCablesCu->DefinePolygon(6, xprof, yprof);
4505 coaxCablesCu->DefineSection(0, 0);
4506 coaxCablesCu->DefineSection(1, kCoaxCableSectCu);
4507
4508 TGeoXtru *coaxCablesPUR = new TGeoXtru(2);
4509
4510 xprof[0] = coaxCablesCu->GetX(5);
4511 yprof[0] = coaxCablesCu->GetY(5);
4512 xprof[1] = coaxCablesCu->GetX(4);
4513 yprof[1] = coaxCablesCu->GetY(4);
4514 xprof[2] = coaxCablesCu->GetX(3);
4515 yprof[2] = coaxCablesCu->GetY(3);
4516 xprof[3] = xprof[2] - kCoaxCableHighPUR*SinD(kTrayCFoldAngle);
4517 yprof[3] = yprof[2] + kCoaxCableHighPUR*CosD(kTrayCFoldAngle);
4518 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4519 kCoaxCableHighPUR , xprof[4], yprof[4]);
4520 xprof[5] = 0.;
4521 yprof[5] = yprof[0] + kCoaxCableHighPUR;
96eb8210 4522
57126ea1 4523 coaxCablesPUR->DefinePolygon(6, xprof, yprof);
4524 coaxCablesPUR->DefineSection(0, 0);
4525 coaxCablesPUR->DefineSection(1, kCoaxCableSectCu);
96eb8210 4526
aa177c73 4527
4528 // We have all shapes: now create the real volumes
4529 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
4530 TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$");
96eb8210 4531 TGeoMedium *medFr = mgr->GetMedium("ITS_Freon$");
aa177c73 4532 TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!!
57126ea1 4533 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
4534 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
aa177c73 4535
4536 TGeoVolume *traySideCHorFace = new TGeoVolume("ITSsuppSPDTraySideCHor",
4537 sideCHorFace, medAl);
4538
4539 traySideCHorFace->SetVisibility(kTRUE);
4540 traySideCHorFace->SetLineColor(6); // Purple
4541 traySideCHorFace->SetLineWidth(1);
4542 traySideCHorFace->SetFillColor(traySideCHorFace->GetLineColor());
4543 traySideCHorFace->SetFillStyle(4000); // 0% transparent
4544
4545 TGeoVolume *traySideCMidFace = new TGeoVolume("ITSsuppSPDTraySideCMid",
4546 sideCMidFace, medAl);
4547
4548 traySideCMidFace->SetVisibility(kTRUE);
4549 traySideCMidFace->SetLineColor(6); // Purple
4550 traySideCMidFace->SetLineWidth(1);
4551 traySideCMidFace->SetFillColor(traySideCMidFace->GetLineColor());
4552 traySideCMidFace->SetFillStyle(4000); // 0% transparent
4553
4554 TGeoVolume *traySideCSideFace = new TGeoVolume("ITSsuppSPDTraySideCSide",
4555 sideCSideFace, medAl);
4556
4557 traySideCSideFace->SetVisibility(kTRUE);
4558 traySideCSideFace->SetLineColor(6); // Purple
4559 traySideCSideFace->SetLineWidth(1);
4560 traySideCSideFace->SetFillColor(traySideCSideFace->GetLineColor());
4561 traySideCSideFace->SetFillStyle(4000); // 0% transparent
4562
4563 TGeoVolume *traySideCShortCover = new TGeoVolume("ITSsuppSPDTraySideCShCov",
4564 sideCShortCover, medAl);
4565
4566 traySideCShortCover->SetVisibility(kTRUE);
4567 traySideCShortCover->SetLineColor(6); // Purple
4568 traySideCShortCover->SetLineWidth(1);
4569 traySideCShortCover->SetFillColor(traySideCShortCover->GetLineColor());
4570 traySideCShortCover->SetFillStyle(4000); // 0% transparent
4571
4572 TGeoVolume *traySideCLongCover = new TGeoVolume("ITSsuppSPDTraySideCLnCov",
4573 sideCLongCover, medAl);
4574
4575 traySideCLongCover->SetVisibility(kTRUE);
4576 traySideCLongCover->SetLineColor(6); // Purple
4577 traySideCLongCover->SetLineWidth(1);
4578 traySideCLongCover->SetFillColor(traySideCLongCover->GetLineColor());
4579 traySideCLongCover->SetFillStyle(4000); // 0% transparent
4580
4581 TGeoVolume *traySideCIntWall = new TGeoVolume("ITSsuppSPDTraySideCWall",
4582 intWall, medAl);
4583
4584 traySideCIntWall->SetVisibility(kTRUE);
4585 traySideCIntWall->SetLineColor(6); // Purple
4586 traySideCIntWall->SetLineWidth(1);
4587 traySideCIntWall->SetFillColor(traySideCIntWall->GetLineColor());
4588 traySideCIntWall->SetFillStyle(4000); // 0% transparent
4589
4590 TGeoVolume *traySideCHorTube = new TGeoVolume("ITSsuppSPDTraySideCHorTube",
4591 horTube, medIn);
4592
4593 traySideCHorTube->SetVisibility(kTRUE);
4594 traySideCHorTube->SetLineColor(kGray); // as in GeometrySPD
4595 traySideCHorTube->SetLineWidth(1);
4596 traySideCHorTube->SetFillColor(traySideCHorTube->GetLineColor());
4597 traySideCHorTube->SetFillStyle(4000); // 0% transparent
4598
96eb8210 4599 TGeoVolume *traySideCHorFreon = new TGeoVolume("ITSsuppSPDTraySideCHorFreon",
4600 horFreon, medFr);
4601
4602 traySideCHorFreon->SetVisibility(kTRUE);
4603 traySideCHorFreon->SetLineColor(kBlue); // Blue
4604 traySideCHorFreon->SetLineWidth(1);
4605 traySideCHorFreon->SetFillColor(traySideCHorFreon->GetLineColor());
4606 traySideCHorFreon->SetFillStyle(4000); // 0% transparent
4607
aa177c73 4608 TGeoVolume *traySideCIncTube = new TGeoVolume("ITSsuppSPDTraySideCIncTube",
4609 incTube, medIn);
4610
4611 traySideCIncTube->SetVisibility(kTRUE);
4612 traySideCIncTube->SetLineColor(kGray); // as in GeometrySPD
4613 traySideCIncTube->SetLineWidth(1);
4614 traySideCIncTube->SetFillColor(traySideCIncTube->GetLineColor());
4615 traySideCIncTube->SetFillStyle(4000); // 0% transparent
4616
96eb8210 4617 TGeoVolume *traySideCIncFreon = new TGeoVolume("ITSsuppSPDTraySideCIncFreon",
4618 incFreon, medFr);
4619
4620 traySideCIncFreon->SetVisibility(kTRUE);
4621 traySideCIncFreon->SetLineColor(kBlue); // Blue
4622 traySideCIncFreon->SetLineWidth(1);
4623 traySideCIncFreon->SetFillColor(traySideCIncFreon->GetLineColor());
4624 traySideCIncFreon->SetFillStyle(4000); // 0% transparent
4625
aa177c73 4626 TGeoVolume *traySideCOptFibs = new TGeoVolume("ITSsuppSPDTraySideCOptFibs",
4627 optFibs, medFibs);
4628
4629 traySideCOptFibs->SetVisibility(kTRUE);
4630 traySideCOptFibs->SetLineColor(kOrange); // Orange
4631 traySideCOptFibs->SetLineWidth(1);
4632 traySideCOptFibs->SetFillColor(traySideCOptFibs->GetLineColor());
4633 traySideCOptFibs->SetFillStyle(4000); // 0% transparent
4634
57126ea1 4635 TGeoVolume *traySideCLowCabsCu = new TGeoVolume("ITSsuppSPDTraySideCLVCu",
4636 lowCablesCu, medCu);
4637
4638 traySideCLowCabsCu->SetVisibility(kTRUE);
4639 traySideCLowCabsCu->SetLineColor(kRed); // Red
4640 traySideCLowCabsCu->SetLineWidth(1);
4641 traySideCLowCabsCu->SetFillColor(traySideCLowCabsCu->GetLineColor());
4642 traySideCLowCabsCu->SetFillStyle(4000); // 0% transparent
4643
4644 TGeoVolume *traySideCLowCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCLVPUR",
4645 lowCablesPUR, medPUR);
4646
4647 traySideCLowCabsPUR->SetVisibility(kTRUE);
4648 traySideCLowCabsPUR->SetLineColor(kBlack); // Black
4649 traySideCLowCabsPUR->SetLineWidth(1);
4650 traySideCLowCabsPUR->SetFillColor(traySideCLowCabsPUR->GetLineColor());
4651 traySideCLowCabsPUR->SetFillStyle(4000); // 0% transparent
aa177c73 4652
57126ea1 4653 TGeoVolume *traySideCHiCabsCu = new TGeoVolume("ITSsuppSPDTraySideCHVCu",
4654 hiCablesCu, medCu);
aa177c73 4655
57126ea1 4656 traySideCHiCabsCu->SetVisibility(kTRUE);
4657 traySideCHiCabsCu->SetLineColor(kRed); // Red
4658 traySideCHiCabsCu->SetLineWidth(1);
4659 traySideCHiCabsCu->SetFillColor(traySideCHiCabsCu->GetLineColor());
4660 traySideCHiCabsCu->SetFillStyle(4000); // 0% transparent
96eb8210 4661
57126ea1 4662 TGeoVolume *traySideCHiCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCHVPUR",
4663 hiCablesPUR, medPUR);
4664
4665 traySideCHiCabsPUR->SetVisibility(kTRUE);
4666 traySideCHiCabsPUR->SetLineColor(kBlack); // Black
4667 traySideCHiCabsPUR->SetLineWidth(1);
4668 traySideCHiCabsPUR->SetFillColor(traySideCHiCabsPUR->GetLineColor());
4669 traySideCHiCabsPUR->SetFillStyle(4000); // 0% transparent
4670
4671 TGeoVolume *traySideCCoaxCu = new TGeoVolume("ITSsuppSPDTraySideCCoaxCu",
4672 coaxCablesCu, medCu);
4673
4674 traySideCCoaxCu->SetVisibility(kTRUE);
4675 traySideCCoaxCu->SetLineColor(kRed); // Red
4676 traySideCCoaxCu->SetLineWidth(1);
4677 traySideCCoaxCu->SetFillColor(traySideCCoaxCu->GetLineColor());
4678 traySideCCoaxCu->SetFillStyle(4000); // 0% transparent
4679
4680 TGeoVolume *traySideCCoaxPUR = new TGeoVolume("ITSsuppSPDTraySideCCoaxPUR",
4681 coaxCablesPUR, medPUR);
4682
4683 traySideCCoaxPUR->SetVisibility(kTRUE);
4684 traySideCCoaxPUR->SetLineColor(kBlack); // Black
4685 traySideCCoaxPUR->SetLineWidth(1);
4686 traySideCCoaxPUR->SetFillColor(traySideCCoaxPUR->GetLineColor());
4687 traySideCCoaxPUR->SetFillStyle(4000); // 0% transparent
96eb8210 4688
aa177c73 4689
4690 // Now build up the trays
4691 cableTrayC->AddNode(traySideCHorFace,1,0);
4692
4693 cableTrayC->AddNode(traySideCMidFace,1,0);
4694
4695 zloc = kTrayCHalfWide - kTrayCThick;
4696 cableTrayC->AddNode(traySideCSideFace, 1,
4697 new TGeoTranslation( 0, 0, zloc));
4698 zloc = -kTrayCHalfWide;
4699 cableTrayC->AddNode(traySideCSideFace, 2,
4700 new TGeoTranslation( 0, 0, zloc));
4701
4702 xloc = sideCShortCover->GetDX();
4703 yloc = kTrayCFirstHigh - sideCShortCover->GetDY();
4704 cableTrayC->AddNode(traySideCShortCover, 1,
4705 new TGeoTranslation( xloc, yloc, 0));
4706
4707 cableTrayC->AddNode(traySideCLongCover,1,0);
4708
4709 cableTrayC->AddNode(traySideCIntWall,1,0);
4710
96eb8210 4711 traySideCHorTube->AddNode(traySideCHorFreon, 1, 0);
4712 traySideCIncTube->AddNode(traySideCIncFreon, 1, 0);
4713
aa177c73 4714 xloc = horTube->GetDz();
4715 yloc = sideCMidFace->GetY(5) + horTube->GetRmax();
4716 cableTrayC->AddNode(traySideCHorTube, 1,
4717 new TGeoCombiTrans( xloc, yloc, 0,
4718 new TGeoRotation("",-90.,-90.,90.)));
4719
4720 xloc = sideCMidFace->GetX(4) + (incTube->GetDz())*CosD(kTrayCFoldAngle);
4721 yloc = sideCMidFace->GetY(4) + incTube->GetRmax() +
4722 (incTube->GetDz())*SinD(kTrayCFoldAngle)+0.005;//Avoid small ovrlp
4723 cableTrayC->AddNode(traySideCIncTube, 1,
4724 new TGeoCombiTrans( xloc, yloc, 0,
4725 new TGeoRotation("",-90.+kTrayCFoldAngle,-90.,90.)));
4726
4727 zloc = horTube->GetRmax();
4728 cableTrayC->AddNode(traySideCOptFibs, 1,
4729 new TGeoTranslation( 0, 0, zloc));
4730
57126ea1 4731 zloc = kLowVoltCableSectCu + horTube->GetRmax();
4732 cableTrayC->AddNode(traySideCLowCabsCu, 1,
4733 new TGeoTranslation( 0, 0,-zloc));
4734 cableTrayC->AddNode(traySideCLowCabsPUR, 1,
aa177c73 4735 new TGeoTranslation( 0, 0,-zloc));
4736
57126ea1 4737 zloc = kHiVoltCableSectCu + kLowVoltCableSectCu + horTube->GetRmax();
4738 cableTrayC->AddNode(traySideCHiCabsCu, 1,
4739 new TGeoTranslation( 0, 0,-zloc));
4740 cableTrayC->AddNode(traySideCHiCabsPUR, 1,
96eb8210 4741 new TGeoTranslation( 0, 0,-zloc));
4742
57126ea1 4743 zloc = kOpticalFibersSect + kCoaxCableSectCu + horTube->GetRmax();
4744 cableTrayC->AddNode(traySideCCoaxCu, 1,
4745 new TGeoTranslation( 0, 0, zloc));
4746 cableTrayC->AddNode(traySideCCoaxPUR, 1,
4747 new TGeoTranslation( 0, 0, zloc));
4748
aa177c73 4749
4750 // Finally put everything in the mother volume
4751 for (Int_t jt = 0; jt < kNumTraysSideC/2; jt++) {
4752 alpharot = kTraySideCAlphaRot[jt];
4753
4754 xloc = kTraySideCRPos*SinD(alpharot);
4755 yloc = kTraySideCRPos*CosD(alpharot);
4756 moth->AddNode(cableTrayC,2*jt+1,
4757 new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
4758 new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle)));
4759 alpharot += 180;
4760 xloc = kTraySideCRPos*SinD(alpharot);
4761 yloc = kTraySideCRPos*CosD(alpharot);
4762 moth->AddNode(cableTrayC,2*jt+2,
4763 new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
4764 new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle)));
4765 }
4766
4767
4768 return;
4769}
4770
798b4e0c 4771//______________________________________________________________________
4772void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
4773 TGeoManager *mgr){
4774//
4775// Creates the SDD cable trays which are outside the ITS support cones
4776// but still inside the TPC on Side A
4777// (part of this code is taken or anyway inspired to ServicesCableSupport
4778// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
4779//
4780// Input:
4781// moth : the TGeoVolume owing the volume structure
4782// mgr : the GeoManager (default gGeoManager)
4783// Output:
4784//
4785// Created: ??? Bjorn S. Nilsen
4786// Updated: 5 Jan 2010 Mario Sitta
4787// Updated: 26 Feb 2010 Mario Sitta
57126ea1 4788// Updated: 06 Sep 2010 Mario Sitta
798b4e0c 4789//
4790// Technical data are taken from AutoCAD drawings, L.Simonetti technical
4791// drawings and other (oral) information given by F.Tosello
4792//
4793
4794 // Overall position and rotation of the A-Side Cable Trays
4795 // (parts of 0872/G/D)
573a206f 4796 const Double_t kTrayARTrans = 408.35 *fgkmm;
798b4e0c 4797 const Double_t kTrayAZTrans = 1011.00 *fgkmm;
4798 const Double_t kTrayAZToSupportRing = 435.00 *fgkmm;
57126ea1 4799 const Double_t kExternTrayYTrans = 96.00 *fgkmm; // Computed
4800 const Double_t kExternTrayZTrans = 823.00 *fgkmm;
798b4e0c 4801 const Double_t kExternCoverYTrans = 2.00 *fgkmm;
4802 const Double_t kTrayAZRot = (180-169.5);// Degrees
4803 const Double_t kTrayAFirstRotAng = 22.00; // Degrees
4804 const Double_t kTrayASecondRotAng = 15.00; // Degrees
4805
57126ea1 4806 const Double_t kForwardTrayThick = 2.00 *fgkmm;
798b4e0c 4807 const Double_t kForwardTrayTailHeight = 100.00 *fgkmm; // Computed
4808 const Double_t kForwardTrayTotalHeight = 170.00 *fgkmm; // Computed
4809 const Double_t kForwardTrayUpperLength = 405.00 *fgkmm; // Computed
4810 const Double_t kForwardCoverLength = 380.00 *fgkmm;
4811 const Double_t kForwardCoverWide = 133.00 *fgkmm;
4812 const Double_t kForwardCoverHeight = 10.00 *fgkmm;
4813 const Double_t kForwardCoverThick = 1.00 *fgkmm;
4814
4815 const Double_t kExternTrayTotalLen = 1200.00 *fgkmm;
4816 const Double_t kExternTrayTotalHeight = 52.00 *fgkmm;
4817 const Double_t kExternCoverLen = kExternTrayTotalLen;
4818 const Double_t kExternCoverThick = 5.00 *fgkmm;
4819 const Double_t kExternCoverSideThick = 3.00 *fgkmm;
4820
4821 const Int_t kForwardTrayNpoints = 8;
4822
57126ea1 4823 // Dimensions and positions of the Cable Tray elements
4824 const Double_t kSideACoolManifWide = 8.23 *fgkcm;
4825 const Double_t kSideACoolManifHigh = 8.06 *fgkcm;
4826 const Double_t kSideACoolManifLen = 3.90 *fgkcm;
4827 const Double_t kSideACoolManifPOMFrac = 0.0054;
4828 const Double_t kSideACoolManifSteelFrac= 0.8850;
4829 const Double_t kSideACoolManifWaterFrac= 0.0913;
4830 const Double_t kSideACoolManifAlFrac = 0.0183;
4831
4832 const Double_t kSideACoolTubesWide = 9.07 *fgkcm;
4833 const Double_t kSideACoolTubesHigh = 1.88 *fgkcm;
4834 const Double_t kSideACoolTubesTrans = 0.88 *fgkcm;
4835 const Double_t kSideACoolTubesPURFrac = 0.5897;
4836 const Double_t kSideACoolTubesWaterFrac= 0.4101;
4837 const Double_t kSideACoolTubesAirFrac = 0.0002;
4838
4839 const Double_t kSideAOptConnWide = 0.90 *fgkcm;
4840 const Double_t kSideAOptConnLen = 1.37 *fgkcm;
4841 const Double_t kSideAOptConnPBTFrac = 0.5010;
4842 const Double_t kSideAOptConnSteelFrac = 0.1784;
4843 const Double_t kSideAOptConnAlFrac = 0.3206;
4844
4845 const Double_t kSideAOptFibsWide = 0.71 *fgkcm;
4846 const Double_t kSideAOptFibsHigh = 3.20 *fgkcm;
4847
4848 const Double_t kSideAInputCablesWide = 12.50 *fgkcm;
4849 const Double_t kSideAInputCablesHigh = 1.24 *fgkcm;
4850 const Double_t kSideAInputCablesLen = 25.20 *fgkcm;
4851 const Double_t kSideAInputCablesYTrans = 1.15 *fgkcm;
4852 const Double_t kSideAInputCablesCu = 0.7404;
4853 const Double_t kSideAInputCablesPlast = 0.1269;
4854 const Double_t kSideAInputCablesAl = 0.0057;
4855 const Double_t kSideAInputCablesKapton = 0.0172;
4856 const Double_t kSideAInputCablesPOLYAX = 0.1098;
4857
4858 const Double_t kSideAOutputCablesWide = 8.30 *fgkcm;
4859 const Double_t kSideAOutputCablesHigh = 1.56 *fgkcm;
4860 const Double_t kSideAOutputCablesCu = 0.6783;
4861 const Double_t kSideAOutputCablesPlast = 0.1605;
4862 const Double_t kSideAOutputCablesAl = 0.0078;
4863 const Double_t kSideAOutputCablesKapton= 0.0232;
4864 const Double_t kSideAOutputCablesPOLYAX= 0.1302;
4865
4866 const Double_t kSideAPCBBoardsWide = 12.50 *fgkcm;
4867 const Double_t kSideAPCBBoardsHigh = 6.32 *fgkcm;
4868 const Double_t kSideAPCBBoardsLen = 24.00 *fgkcm;
4869 const Double_t kSideAPCBBoardsYTrans = 0.75 *fgkcm;
4870 const Double_t kSideAPCBBoardsCu = 0.3864;
4871 const Double_t kSideAPCBBoardsEpoxy = 0.1486;
4872 const Double_t kSideAPCBBoardsPlast = 0.0578;
4873 const Double_t kSideAPCBBoardsSteel = 0.1521;
4874 const Double_t kSideAPCBBoardsPPS = 0.2551;
4875
798b4e0c 4876
4877 // Local variables
4878 Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
57126ea1 4879 Double_t xloc, yloc, zloc, alpharot, height;
798b4e0c 4880
4881
4882 // The whole tray as an assembly
4883 TGeoVolumeAssembly *cableTrayA = new TGeoVolumeAssembly("ITSsupportSDDTrayA");
4884
4885
4886 // First create all needed shapes
4887
4888 // The forward tray is very complex and deserves a dedicated method
57126ea1 4889 CreateSDDForwardTraySideA(cableTrayA,mgr);
798b4e0c 4890
4891 // The forward cover: a Xtru
4892 TGeoXtru *forwardCover = new TGeoXtru(2);
4893 forwardCover->SetName("ITSsuppSDDForwCover");
4894
4895 xprof[0] = kForwardCoverWide/2;
4896 yprof[0] = kForwardCoverHeight;
4897 xprof[1] = xprof[0];
4898 yprof[1] = 0;
4899 xprof[2] = xprof[1] - kForwardCoverThick;
4900 yprof[2] = yprof[1];
4901 xprof[3] = xprof[2];
4902 yprof[3] = yprof[0] - kForwardCoverThick;
4903
4904 // We did the right side, now reflex on the left side
4905 for (Int_t jp = 0; jp < 4; jp++) {
4906 xprof[4+jp] = -xprof[3-jp];
4907 yprof[4+jp] = yprof[3-jp];
4908 }
4909
4910 forwardCover->DefinePolygon(8, xprof, yprof);
4911 forwardCover->DefineSection(0, 0);
4912 forwardCover->DefineSection(1, kForwardCoverLength);
4913
4914 // The external tray (as 0872/G/D/03): a Xtru
4915 TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternTrayTotalLen,
4916 kExternTrayTotalHeight);
4917
4918 // The external covers: a Composite Shape
4919 TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternCoverLen);
4920
57126ea1 4921 // Now the volumes inside it
4922 // The cooling manifold: four boxes
4923 TGeoBBox *coolManifPOM = new TGeoBBox(kSideACoolManifWide/2,
4924 kSideACoolManifPOMFrac*kSideACoolManifHigh/2,
4925 kSideACoolManifLen/2);
4926
4927 TGeoBBox *coolManifSteel = new TGeoBBox(kSideACoolManifWide/2,
4928 kSideACoolManifSteelFrac*kSideACoolManifHigh/2,
4929 kSideACoolManifLen/2);
4930
4931 TGeoBBox *coolManifWater = new TGeoBBox(kSideACoolManifWide/2,
4932 kSideACoolManifWaterFrac*kSideACoolManifHigh/2,
4933 kSideACoolManifLen/2);
4934
4935 TGeoBBox *coolManifAl = new TGeoBBox(kSideACoolManifWide/2,
4936 kSideACoolManifAlFrac*kSideACoolManifHigh/2,
4937 kSideACoolManifLen/2);
4938
4939 // The cooling tubes: three Xtru's
4940 TGeoXtru *coolTubesPUR = new TGeoXtru(2);
4941
4942 height = kSideACoolTubesHigh*kSideACoolTubesPURFrac;
4943
4944 xprof[0] = kSideACoolManifLen;
4945 yprof[0] = kForwardTrayThick + kSideACoolTubesTrans;
4946 xprof[2] = kExternTrayZTrans + kForwardTrayTotalHeight*SinD(kTrayAZRot) +
4947 kExternTrayTotalLen*CosD(kTrayAZRot) - xprof[0]/2;
4948 yprof[2] = kForwardTrayTotalHeight*(1 - CosD(kTrayAZRot)) +
4949 kExternTrayYTrans - kExternTrayTotalHeight*CosD(kTrayAZRot) +
4950 kExternTrayTotalLen*SinD(kTrayAZRot) + yprof[0];
4951 IntersectLines( 0 , xprof[0], yprof[0],
4952 TanD(kTrayAZRot), xprof[2], yprof[2],
4953 xprof[1], yprof[1]);
4954 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
4955 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
4956 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4957 height, xprof[4], yprof[4]);
4958 xprof[5] = xprof[0];
4959 yprof[5] = yprof[0] + height;
4960
4961 coolTubesPUR->DefinePolygon(6, xprof, yprof);
4962 coolTubesPUR->DefineSection(0,-kSideACoolTubesWide/2);
4963 coolTubesPUR->DefineSection(1, kSideACoolTubesWide/2);
4964
4965 TGeoXtru *coolTubesWater = new TGeoXtru(2);
4966
4967 height = kSideACoolTubesHigh*kSideACoolTubesWaterFrac;
4968
4969 xprof[0] = coolTubesPUR->GetX(5);
4970 yprof[0] = coolTubesPUR->GetY(5);
4971 xprof[1] = coolTubesPUR->GetX(4);
4972 yprof[1] = coolTubesPUR->GetY(4);
4973 xprof[2] = coolTubesPUR->GetX(3);
4974 yprof[2] = coolTubesPUR->GetY(3);
4975 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
4976 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
4977 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4978 height, xprof[4], yprof[4]);
4979 xprof[5] = xprof[0];
4980 yprof[5] = yprof[0] + height;
4981
4982 coolTubesWater->DefinePolygon(6, xprof, yprof);
4983 coolTubesWater->DefineSection(0,-kSideACoolTubesWide/2);
4984 coolTubesWater->DefineSection(1, kSideACoolTubesWide/2);
4985
4986 TGeoXtru *coolTubesAir = new TGeoXtru(2);
4987
4988 height = kSideACoolTubesHigh*kSideACoolTubesAirFrac;
4989
4990 xprof[0] = coolTubesWater->GetX(5);
4991 yprof[0] = coolTubesWater->GetY(5);
4992 xprof[1] = coolTubesWater->GetX(4);
4993 yprof[1] = coolTubesWater->GetY(4);
4994 xprof[2] = coolTubesWater->GetX(3);
4995 yprof[2] = coolTubesWater->GetY(3);
4996 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
4997 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
4998 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4999 height, xprof[4], yprof[4]);
5000 xprof[5] = xprof[0];
5001 yprof[5] = yprof[0] + height;
5002
5003 coolTubesAir->DefinePolygon(6, xprof, yprof);
5004 coolTubesAir->DefineSection(0,-kSideACoolTubesWide/2);
5005 coolTubesAir->DefineSection(1, kSideACoolTubesWide/2);
5006
5007 // The optical fiber connectors: three boxes
5008 TGeoBBox *optConnPBT = new TGeoBBox(kSideAOptConnWide/2,
5009 kSideAOptConnPBTFrac*kSideACoolManifHigh/2,
5010 kSideAOptConnLen/2);
5011
5012 TGeoBBox *optConnSteel = new TGeoBBox(kSideAOptConnWide/2,
5013 kSideAOptConnSteelFrac*kSideACoolManifHigh/2,
5014 kSideAOptConnLen/2);
5015
5016 TGeoBBox *optConnAl = new TGeoBBox(kSideAOptConnWide/2,
5017 kSideAOptConnAlFrac*kSideACoolManifHigh/2,
5018 kSideAOptConnLen/2);
5019
5020 // The optical fibers: a Xtru
5021 TGeoXtru *opticalFibs = new TGeoXtru(2);
5022
5023 xprof[0] = kSideAOptConnLen;
5024 yprof[0] = coolTubesPUR->GetY(0);
5025 xprof[1] = coolTubesPUR->GetX(1);
5026 yprof[1] = coolTubesPUR->GetY(1);
5027 xprof[2] = coolTubesPUR->GetX(2);
5028 yprof[2] = coolTubesPUR->GetY(2);
5029 xprof[3] = xprof[2] - kSideAOptFibsHigh*SinD(kTrayAZRot);
5030 yprof[3] = yprof[2] + kSideAOptFibsHigh*CosD(kTrayAZRot);
5031 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5032 kSideAOptFibsHigh, xprof[4], yprof[4]);
5033 xprof[5] = xprof[0];
5034 yprof[5] = yprof[0] + kSideAOptFibsHigh;
5035
5036 opticalFibs->DefinePolygon(6, xprof, yprof);
5037 opticalFibs->DefineSection(0,-kSideAOptFibsWide/2);
5038 opticalFibs->DefineSection(1, kSideAOptFibsWide/2);
5039
5040 // The input cables: five boxes
5041 TGeoBBox *inputCabsCu = new TGeoBBox(kSideAInputCablesWide/2,
5042 kSideAInputCablesCu*kSideAInputCablesHigh/2,
5043 kSideAInputCablesLen/2);
5044
5045 TGeoBBox *inputCabsPlast = new TGeoBBox(kSideAInputCablesWide/2,
5046 kSideAInputCablesPlast*kSideAInputCablesHigh/2,
5047 kSideAInputCablesLen/2);
5048
5049 TGeoBBox *inputCabsAl = new TGeoBBox(kSideAInputCablesWide/2,
5050 kSideAInputCablesAl*kSideAInputCablesHigh/2,
5051 kSideAInputCablesLen/2);
5052
5053 TGeoBBox *inputCabsKapton = new TGeoBBox(kSideAInputCablesWide/2,
5054 kSideAInputCablesKapton*kSideAInputCablesHigh/2,
5055 kSideAInputCablesLen/2);
5056
5057 TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideAInputCablesWide/2,
5058 kSideAInputCablesPOLYAX*kSideAInputCablesHigh/2,
5059 kSideAInputCablesLen/2);
5060
5061 // The output cables: five Xtru
5062 TGeoXtru *outputCabsCu = new TGeoXtru(2);
5063
5064 height = kSideAOutputCablesCu*kSideAOutputCablesHigh;
5065
5066 xprof[0] = kSideAInputCablesLen/2 + kSideAPCBBoardsLen/2;
5067 yprof[0] = coolTubesAir->GetY(5);
5068 xprof[1] = coolTubesAir->GetX(4);
5069 yprof[1] = coolTubesAir->GetY(4);
5070 xprof[2] = coolTubesAir->GetX(3);
5071 yprof[2] = coolTubesAir->GetY(3);
5072 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5073 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5074 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5075 height, xprof[4], yprof[4]);
5076 xprof[5] = xprof[0];
5077 yprof[5] = yprof[0] + height;
5078
5079 outputCabsCu->DefinePolygon(6, xprof, yprof);
5080 outputCabsCu->DefineSection(0,-kSideAOutputCablesWide/2);
5081 outputCabsCu->DefineSection(1, kSideAOutputCablesWide/2);
5082
5083 TGeoXtru *outputCabsPlast = new TGeoXtru(2);
5084
5085 height = kSideAOutputCablesPlast*kSideAOutputCablesHigh;
5086
5087 xprof[0] = outputCabsCu->GetX(5);
5088 yprof[0] = outputCabsCu->GetY(5);
5089 xprof[1] = outputCabsCu->GetX(4);
5090 yprof[1] = outputCabsCu->GetY(4);
5091 xprof[2] = outputCabsCu->GetX(3);
5092 yprof[2] = outputCabsCu->GetY(3);
5093 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5094 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5095 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5096 height, xprof[4], yprof[4]);
5097 xprof[5] = xprof[0];
5098 yprof[5] = yprof[0] + height;
5099
5100 outputCabsPlast->DefinePolygon(6, xprof, yprof);
5101 outputCabsPlast->DefineSection(0,-kSideAOutputCablesWide/2);
5102 outputCabsPlast->DefineSection(1, kSideAOutputCablesWide/2);
5103
5104 TGeoXtru *outputCabsAl = new TGeoXtru(2);
5105
5106 height = kSideAOutputCablesAl*kSideAOutputCablesHigh;
5107
5108 xprof[0] = outputCabsPlast->GetX(5);
5109 yprof[0] = outputCabsPlast->GetY(5);
5110 xprof[1] = outputCabsPlast->GetX(4);
5111 yprof[1] = outputCabsPlast->GetY(4);
5112 xprof[2] = outputCabsPlast->GetX(3);
5113 yprof[2] = outputCabsPlast->GetY(3);
5114 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5115 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5116 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5117 height, xprof[4], yprof[4]);
5118 xprof[5] = xprof[0];
5119 yprof[5] = yprof[0] + height;
5120
5121 outputCabsAl->DefinePolygon(6, xprof, yprof);
5122 outputCabsAl->DefineSection(0,-kSideAOutputCablesWide/2);
5123 outputCabsAl->DefineSection(1, kSideAOutputCablesWide/2);
5124
5125 TGeoXtru *outputCabsKapton = new TGeoXtru(2);
5126
5127 height = kSideAOutputCablesKapton*kSideAOutputCablesHigh;
5128
5129 xprof[0] = outputCabsAl->GetX(5);
5130 yprof[0] = outputCabsAl->GetY(5);
5131 xprof[1] = outputCabsAl->GetX(4);
5132 yprof[1] = outputCabsAl->GetY(4);
5133 xprof[2] = outputCabsAl->GetX(3);
5134 yprof[2] = outputCabsAl->GetY(3);
5135 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5136 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5137 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5138 height, xprof[4], yprof[4]);
5139 xprof[5] = xprof[0];
5140 yprof[5] = yprof[0] + height;
5141
5142 outputCabsKapton->DefinePolygon(6, xprof, yprof);
5143 outputCabsKapton->DefineSection(0,-kSideAOutputCablesWide/2);
5144 outputCabsKapton->DefineSection(1, kSideAOutputCablesWide/2);
5145
5146 TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
5147
5148 height = kSideAOutputCablesPOLYAX*kSideAOutputCablesHigh;
5149
5150 xprof[0] = outputCabsKapton->GetX(5);
5151 yprof[0] = outputCabsKapton->GetY(5);
5152 xprof[1] = outputCabsKapton->GetX(4);
5153 yprof[1] = outputCabsKapton->GetY(4);
5154 xprof[2] = outputCabsKapton->GetX(3);
5155 yprof[2] = outputCabsKapton->GetY(3);
5156 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5157 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5158 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5159 height, xprof[4], yprof[4]);
5160 xprof[5] = xprof[0];
5161 yprof[5] = yprof[0] + height;
5162
5163 outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
5164 outputCabsPOLYAX->DefineSection(0,-kSideAOutputCablesWide/2);
5165 outputCabsPOLYAX->DefineSection(1, kSideAOutputCablesWide/2);
5166
5167 // The PCB boards: five boxes
5168 TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideAPCBBoardsWide/2,
5169 kSideAPCBBoardsCu*kSideAPCBBoardsHigh/2,
5170 kSideAPCBBoardsLen/2);
5171
5172 TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideAPCBBoardsWide/2,
5173 kSideAPCBBoardsEpoxy*kSideAPCBBoardsHigh/2,
5174 kSideAPCBBoardsLen/2);
5175
5176 TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideAPCBBoardsWide/2,
5177 kSideAPCBBoardsPlast*kSideAPCBBoardsHigh/2,
5178 kSideAPCBBoardsLen/2);
5179
5180 TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideAPCBBoardsWide/2,
5181 kSideAPCBBoardsSteel*kSideAPCBBoardsHigh/2,
5182 kSideAPCBBoardsLen/2);
5183
5184 TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideAPCBBoardsWide/2,
5185 kSideAPCBBoardsPPS*kSideAPCBBoardsHigh/2,
5186 kSideAPCBBoardsLen/2);
5187
798b4e0c 5188
5189 // We have all shapes: now create the real volumes
57126ea1 5190 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
5191 TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
5192 TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
5193 TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$");
5194 TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$");
5195 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
5196 TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
5197 TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$");
5198 TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
5199 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
5200 TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
5201 TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
5202 TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$");
5203 TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$");
798b4e0c 5204
5205 TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSDDSideAForwTrayCover",
5206 forwardCover, medAl);
5207
5208 forwardTrayCover->SetVisibility(kTRUE);
5209 forwardTrayCover->SetLineColor(kMagenta+1); // Purple
5210 forwardTrayCover->SetLineWidth(1);
5211 forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
5212 forwardTrayCover->SetFillStyle(4000); // 0% transparent
5213
5214 TGeoVolume *externalTraySDD = new TGeoVolume("ITSsuppSDDSideAExternalTray",
5215 externalTray, medAl);
5216
5217 externalTraySDD->SetVisibility(kTRUE);
5218 externalTraySDD->SetLineColor(6); // Purple
5219 externalTraySDD->SetLineWidth(1);
5220 externalTraySDD->SetFillColor(externalTraySDD->GetLineColor());
5221 externalTraySDD->SetFillStyle(4000); // 0% transparent
5222
5223 TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSDDSideAExtTrayCover",
5224 externCover, medAntic);
5225
5226 externTrayCover->SetVisibility(kTRUE);
5227 externTrayCover->SetLineColor(kMagenta+1); // Purple
5228 externTrayCover->SetLineWidth(1);
5229 externTrayCover->SetFillColor(externTrayCover->GetLineColor());
5230 externTrayCover->SetFillStyle(4000); // 0% transparent
5231
57126ea1 5232 TGeoVolume *POMCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifPOM",
5233 coolManifPOM, medPOM);
5234
5235 POMCoolManif->SetVisibility(kTRUE);
5236 POMCoolManif->SetLineColor(kRed); // Red
5237 POMCoolManif->SetLineWidth(1);
5238 POMCoolManif->SetFillColor(POMCoolManif->GetLineColor());
5239 POMCoolManif->SetFillStyle(4000); // 0% transparent
5240
5241 TGeoVolume *SteelCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifSteel",
5242 coolManifSteel, medSteel);
5243
5244 SteelCoolManif->SetVisibility(kTRUE);
5245 SteelCoolManif->SetLineColor(kBlue); // Blue
5246 SteelCoolManif->SetLineWidth(1);
5247 SteelCoolManif->SetFillColor(SteelCoolManif->GetLineColor());
5248 SteelCoolManif->SetFillStyle(4000); // 0% transparent
5249
5250 TGeoVolume *WaterCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifWater",
5251 coolManifWater, medWater);
5252
5253 WaterCoolManif->SetVisibility(kTRUE);
5254 WaterCoolManif->SetLineColor(33); // Light Blue
5255 WaterCoolManif->SetLineWidth(1);
5256 WaterCoolManif->SetFillColor(WaterCoolManif->GetLineColor());
5257 WaterCoolManif->SetFillStyle(4000); // 0% transparent
5258
5259 TGeoVolume *AlCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifAl",
5260 coolManifAl, medAl);
5261
5262 AlCoolManif->SetVisibility(kTRUE);
5263 AlCoolManif->SetLineColor(6); // Purple
5264 AlCoolManif->SetLineWidth(1);
5265 AlCoolManif->SetFillColor(AlCoolManif->GetLineColor());
5266 AlCoolManif->SetFillStyle(4000); // 0% transparent
5267
5268 TGeoVolume *PURCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesPUR",
5269 coolTubesPUR, medPUR);
5270
5271 PURCoolTubes->SetVisibility(kTRUE);
5272 PURCoolTubes->SetLineColor(kRed); // Red
5273 PURCoolTubes->SetLineWidth(1);
5274 PURCoolTubes->SetFillColor(PURCoolTubes->GetLineColor());
5275 PURCoolTubes->SetFillStyle(4000); // 0% transparent
5276
5277 TGeoVolume *WaterCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesWater",
5278 coolTubesWater, medWater);
5279
5280 WaterCoolTubes->SetVisibility(kTRUE);
5281 WaterCoolTubes->SetLineColor(33); // Light Blue
5282 WaterCoolTubes->SetLineWidth(1);
5283 WaterCoolTubes->SetFillColor(WaterCoolTubes->GetLineColor());
5284 WaterCoolTubes->SetFillStyle(4000); // 0% transparent
5285
5286 TGeoVolume *AirCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesAir",
5287 coolTubesAir, medAir);
5288
5289 AirCoolTubes->SetVisibility(kTRUE);
5290 AirCoolTubes->SetLineColor(41);
5291 AirCoolTubes->SetLineWidth(1);
5292 AirCoolTubes->SetFillColor(AirCoolTubes->GetLineColor());
5293 AirCoolTubes->SetFillStyle(4000); // 0% transparent
5294
5295 TGeoVolume *PBTOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnPBT",
5296 optConnPBT, medPBT);
5297
5298 PBTOptConn->SetVisibility(kTRUE);
5299 PBTOptConn->SetLineColor(kRed); // Red
5300 PBTOptConn->SetLineWidth(1);
5301 PBTOptConn->SetFillColor(PBTOptConn->GetLineColor());
5302 PBTOptConn->SetFillStyle(4000); // 0% transparent
5303
5304 TGeoVolume *SteelOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnSteel",
5305 optConnSteel, medSteel);
5306
5307 SteelOptConn->SetVisibility(kTRUE);
5308 SteelOptConn->SetLineColor(kBlue); // Blue
5309 SteelOptConn->SetLineWidth(1);
5310 SteelOptConn->SetFillColor(SteelOptConn->GetLineColor());
5311 SteelOptConn->SetFillStyle(4000); // 0% transparent
5312
5313 TGeoVolume *AlOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnAl",
5314 optConnAl, medAl);
5315
5316 AlOptConn->SetVisibility(kTRUE);
5317 AlOptConn->SetLineColor(6); // Purple
5318 AlOptConn->SetLineWidth(1);
5319 AlOptConn->SetFillColor(AlOptConn->GetLineColor());
5320 AlOptConn->SetFillStyle(4000); // 0% transparent
5321
5322 TGeoVolume *OptFibs = new TGeoVolume("ITSsuppSDDSideAOptFibs",
5323 opticalFibs, medOptFib);
5324
5325 OptFibs->SetVisibility(kTRUE);
5326 OptFibs->SetLineColor(kOrange+2); // Orange
5327 OptFibs->SetLineWidth(1);
5328 OptFibs->SetFillColor(OptFibs->GetLineColor());
5329 OptFibs->SetFillStyle(4000); // 0% transparent
5330
5331 TGeoVolume *CuInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsCu",
5332 inputCabsCu, medCu);
5333
5334 CuInputCabs->SetVisibility(kTRUE);
5335 CuInputCabs->SetLineColor(kBlack); // Black
5336 CuInputCabs->SetLineWidth(1);
5337 CuInputCabs->SetFillColor(CuInputCabs->GetLineColor());
5338 CuInputCabs->SetFillStyle(4000); // 0% transparent
5339
5340 TGeoVolume *PlastInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPlast",
5341 inputCabsPlast, medPUR);
5342
5343 PlastInputCabs->SetVisibility(kTRUE);
5344 PlastInputCabs->SetLineColor(kRed); // Red
5345 PlastInputCabs->SetLineWidth(1);
5346 PlastInputCabs->SetFillColor(PlastInputCabs->GetLineColor());
5347 PlastInputCabs->SetFillStyle(4000); // 0% transparent
5348
5349 TGeoVolume *AlInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsAl",
5350 inputCabsAl, medAl);
5351
5352 AlInputCabs->SetVisibility(kTRUE);
5353 AlInputCabs->SetLineColor(6); // Purple
5354 AlInputCabs->SetLineWidth(1);
5355 AlInputCabs->SetFillColor(AlInputCabs->GetLineColor());
5356 AlInputCabs->SetFillStyle(4000); // 0% transparent
5357
5358 TGeoVolume *KaptonInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsKapton",
5359 inputCabsKapton, medKapton);
5360
5361 KaptonInputCabs->SetVisibility(kTRUE);
5362 KaptonInputCabs->SetLineColor(14); //
5363 KaptonInputCabs->SetLineWidth(1);
5364 KaptonInputCabs->SetFillColor(KaptonInputCabs->GetLineColor());
5365 KaptonInputCabs->SetFillStyle(4000); // 0% transparent
5366
5367 TGeoVolume *POLYAXInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPOLYAX",
5368 inputCabsPOLYAX, medPOLYAX);
5369
5370 POLYAXInputCabs->SetVisibility(kTRUE);
5371 POLYAXInputCabs->SetLineColor(34); //
5372 POLYAXInputCabs->SetLineWidth(1);
5373 POLYAXInputCabs->SetFillColor(POLYAXInputCabs->GetLineColor());
5374 POLYAXInputCabs->SetFillStyle(4000); // 0% transparent
5375
5376 TGeoVolume *CuOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsCu",
5377 outputCabsCu, medCu);
5378
5379 CuOutputCabs->SetVisibility(kTRUE);
5380 CuOutputCabs->SetLineColor(kBlack); // Black
5381 CuOutputCabs->SetLineWidth(1);
5382 CuOutputCabs->SetFillColor(CuOutputCabs->GetLineColor());
5383 CuOutputCabs->SetFillStyle(4000); // 0% transparent
5384
5385 TGeoVolume *PlastOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPlast",
5386 outputCabsPlast, medPUR);
5387
5388 PlastOutputCabs->SetVisibility(kTRUE);
5389 PlastOutputCabs->SetLineColor(kRed); // Red
5390 PlastOutputCabs->SetLineWidth(1);
5391 PlastOutputCabs->SetFillColor(PlastOutputCabs->GetLineColor());
5392 PlastOutputCabs->SetFillStyle(4000); // 0% transparent
5393
5394 TGeoVolume *AlOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsAl",
5395 outputCabsAl, medAl);
5396
5397 AlOutputCabs->SetVisibility(kTRUE);
5398 AlOutputCabs->SetLineColor(6); // Purple
5399 AlOutputCabs->SetLineWidth(1);
5400 AlOutputCabs->SetFillColor(AlOutputCabs->GetLineColor());
5401 AlOutputCabs->SetFillStyle(4000); // 0% transparent
5402
5403 TGeoVolume *KaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsKapton",
5404 outputCabsKapton, medKapton);
5405
5406 KaptonOutputCabs->SetVisibility(kTRUE);
5407 KaptonOutputCabs->SetLineColor(14); //
5408 KaptonOutputCabs->SetLineWidth(1);
5409 KaptonOutputCabs->SetFillColor(KaptonOutputCabs->GetLineColor());
5410 KaptonOutputCabs->SetFillStyle(4000); // 0% transparent
5411
5412 TGeoVolume *POLYAXOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPOLYAX",
5413 outputCabsPOLYAX, medPOLYAX);
5414
5415 POLYAXOutputCabs->SetVisibility(kTRUE);
5416 POLYAXOutputCabs->SetLineColor(34); //
5417 POLYAXOutputCabs->SetLineWidth(1);
5418 POLYAXOutputCabs->SetFillColor(POLYAXOutputCabs->GetLineColor());
5419 POLYAXOutputCabs->SetFillStyle(4000); // 0% transparent
5420
5421 TGeoVolume *CuPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsCu",
5422 pcbBoardsCu, medCu);
5423
5424 CuPCBBoards->SetVisibility(kTRUE);
5425 CuPCBBoards->SetLineColor(kBlack); // Black
5426 CuPCBBoards->SetLineWidth(1);
5427 CuPCBBoards->SetFillColor(CuPCBBoards->GetLineColor());
5428 CuPCBBoards->SetFillStyle(4000); // 0% transparent
5429
5430 TGeoVolume *EpoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsEpoxy",
5431 pcbBoardsEpoxy, medEpoxy);
5432
5433 EpoxyPCBBoards->SetVisibility(kTRUE);
5434 EpoxyPCBBoards->SetLineColor(22); //
5435 EpoxyPCBBoards->SetLineWidth(1);
5436 EpoxyPCBBoards->SetFillColor(EpoxyPCBBoards->GetLineColor());
5437 EpoxyPCBBoards->SetFillStyle(4000); // 0% transparent
5438
5439 TGeoVolume *PlastPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPlast",
5440 pcbBoardsPlast, medPUR);
5441
5442 PlastPCBBoards->SetVisibility(kTRUE);
5443 PlastPCBBoards->SetLineColor(kRed); // Red
5444 PlastPCBBoards->SetLineWidth(1);
5445 PlastPCBBoards->SetFillColor(PlastPCBBoards->GetLineColor());
5446 PlastPCBBoards->SetFillStyle(4000); // 0% transparent
5447
5448 TGeoVolume *SteelPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsSteel",
5449 pcbBoardsSteel, medSteel);
5450
5451 SteelPCBBoards->SetVisibility(kTRUE);
5452 SteelPCBBoards->SetLineColor(kBlue); // Blue
5453 SteelPCBBoards->SetLineWidth(1);
5454 SteelPCBBoards->SetFillColor(SteelPCBBoards->GetLineColor());
5455 SteelPCBBoards->SetFillStyle(4000); // 0% transparent
5456
5457 TGeoVolume *PPSPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPPS",
5458 pcbBoardsPPS, medPPS);
5459
5460 PPSPCBBoards->SetVisibility(kTRUE);
5461 PPSPCBBoards->SetLineColor(kGreen); // Green
5462 PPSPCBBoards->SetLineWidth(1);
5463 PPSPCBBoards->SetFillColor(PPSPCBBoards->GetLineColor());
5464 PPSPCBBoards->SetFillStyle(4000); // 0% transparent
5465
798b4e0c 5466
5467 // Now build up the tray
57126ea1 5468 yloc = kForwardTrayTotalHeight - forwardCover->GetY(3);
5469 zloc = kForwardTrayUpperLength - kForwardCoverLength;
798b4e0c 5470 cableTrayA->AddNode(forwardTrayCover, 1,
5471 new TGeoTranslation( 0, yloc, zloc) );
5472
5473 Double_t totalhi = kExternTrayTotalHeight + kExternCoverThick
5474 - kExternCoverYTrans;
5475
57126ea1 5476 yloc = totalhi*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
5477 kExternTrayTotalHeight*CosD(kTrayAZRot);
798b4e0c 5478 zloc = kExternTrayZTrans + totalhi*SinD(kTrayAZRot);
5479 cableTrayA->AddNode(externalTraySDD, 1,
5480 new TGeoCombiTrans( 0, yloc, zloc,
5481 new TGeoRotation("", 0,-kTrayAZRot, 0) ) );
5482
57126ea1 5483 yloc = kExternCoverThick*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
5484 kExternCoverYTrans*CosD(kTrayAZRot)/2-0.01;
5485 zloc = kExternTrayZTrans + kExternCoverThick*SinD(kTrayAZRot);
798b4e0c 5486 cableTrayA->AddNode(externTrayCover,1,
5487 new TGeoCombiTrans( 0, yloc, zloc,
5488 new TGeoRotation("", 0,-kTrayAZRot, 0) ) );
5489
57126ea1 5490 yloc = kForwardTrayThick + coolManifPOM->GetDY();
5491 zloc = coolManifPOM->GetDZ();
5492 cableTrayA->AddNode(POMCoolManif, 1,
5493 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 5494
57126ea1 5495 yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
5496 cableTrayA->AddNode(SteelCoolManif, 1,
5497 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 5498
57126ea1 5499 yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
5500 cableTrayA->AddNode(WaterCoolManif, 1,
5501 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 5502
57126ea1 5503 yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
5504 cableTrayA->AddNode(AlCoolManif, 1,
5505 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 5506
57126ea1 5507 cableTrayA->AddNode(PURCoolTubes,1,
5508 new TGeoCombiTrans( 0, 0, 0,
5509 new TGeoRotation("",-90, 90, 90) ) );
5510 cableTrayA->AddNode(WaterCoolTubes,1,
5511 new TGeoCombiTrans( 0, 0, 0,
5512 new TGeoRotation("",-90, 90, 90) ) );
5513 cableTrayA->AddNode(AirCoolTubes,1,
5514 new TGeoCombiTrans( 0, 0, 0,
5515 new TGeoRotation("",-90, 90, 90) ) );
5516
5517 xloc = coolManifPOM->GetDX() + optConnPBT->GetDX();
5518 yloc = kForwardTrayThick + optConnPBT->GetDY();
5519 zloc = optConnPBT->GetDZ();
5520 cableTrayA->AddNode(PBTOptConn, 1,
5521 new TGeoTranslation( xloc, yloc, zloc) );
5522 cableTrayA->AddNode(PBTOptConn, 2,
5523 new TGeoTranslation(-xloc, yloc, zloc) );
5524
5525 yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
5526 cableTrayA->AddNode(SteelOptConn, 1,
5527 new TGeoTranslation( xloc, yloc, zloc) );
5528 cableTrayA->AddNode(SteelOptConn, 2,
5529 new TGeoTranslation(-xloc, yloc, zloc) );
5530
5531 yloc += optConnSteel->GetDY() + optConnAl->GetDY();
5532 cableTrayA->AddNode(AlOptConn, 1,
5533 new TGeoTranslation( xloc, yloc, zloc) );
5534 cableTrayA->AddNode(AlOptConn, 2,
5535 new TGeoTranslation(-xloc, yloc, zloc) );
5536
5537
5538 xloc = kSideACoolTubesWide/2 + kSideAOptFibsWide/2;
5539 cableTrayA->AddNode(OptFibs,1,
5540 new TGeoCombiTrans( xloc, 0, 0,
5541 new TGeoRotation("",-90, 90, 90) ) );
5542 cableTrayA->AddNode(OptFibs,2,
5543 new TGeoCombiTrans(-xloc, 0, 0,
5544 new TGeoRotation("",-90, 90, 90) ) );
5545
5546 yloc = kForwardTrayTotalHeight - forwardCover->GetY(3) -
5547 kSideAInputCablesYTrans - inputCabsPOLYAX->GetDY();
5548 zloc = inputCabsPOLYAX->GetDZ();
5549 cableTrayA->AddNode(POLYAXInputCabs, 1,
5550 new TGeoTranslation( 0, yloc, zloc) );
5551
5552 yloc -= (inputCabsPOLYAX->GetDY() + inputCabsKapton->GetDY());
5553 cableTrayA->AddNode(KaptonInputCabs, 1,
5554 new TGeoTranslation( 0, yloc, zloc) );
5555
5556 yloc -= (inputCabsKapton->GetDY() + inputCabsAl->GetDY());
5557 cableTrayA->AddNode(AlInputCabs, 1,
5558 new TGeoTranslation( 0, yloc, zloc) );
5559
5560 yloc -= (inputCabsAl->GetDY() + inputCabsPlast->GetDY());
5561 cableTrayA->AddNode(PlastInputCabs, 1,
5562 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 5563
57126ea1 5564 yloc -= (inputCabsPlast->GetDY() + inputCabsCu->GetDY());
5565 cableTrayA->AddNode(CuInputCabs, 1,
5566 new TGeoTranslation( 0, yloc, zloc) );
5567
5568 yloc -= (inputCabsCu->GetDY()+pcbBoardsPPS->GetDY()+kSideAPCBBoardsYTrans);
5569 zloc += pcbBoardsPPS->GetDZ();
5570 cableTrayA->AddNode(PPSPCBBoards, 1,
5571 new TGeoTranslation( 0, yloc, zloc) );
5572
5573 yloc -= (pcbBoardsPPS->GetDY()+pcbBoardsSteel->GetDY());
5574 cableTrayA->AddNode(SteelPCBBoards, 1,
5575 new TGeoTranslation( 0, yloc, zloc) );
5576
5577 yloc -= (pcbBoardsSteel->GetDY()+pcbBoardsPlast->GetDY());
5578 cableTrayA->AddNode(PlastPCBBoards, 1,
5579 new TGeoTranslation( 0, yloc, zloc) );
5580
5581 yloc -= (pcbBoardsPlast->GetDY()+pcbBoardsEpoxy->GetDY());
5582 cableTrayA->AddNode(EpoxyPCBBoards, 1,
5583 new TGeoTranslation( 0, yloc, zloc) );
5584
5585 yloc -= (pcbBoardsEpoxy->GetDY()+pcbBoardsCu->GetDY());
5586 cableTrayA->AddNode(CuPCBBoards, 1,
5587 new TGeoTranslation( 0, yloc, zloc) );
5588
5589 cableTrayA->AddNode(CuOutputCabs,1,
5590 new TGeoCombiTrans( 0, 0, 0,
5591 new TGeoRotation("",-90, 90, 90) ) );
5592 cableTrayA->AddNode(PlastOutputCabs,1,
5593 new TGeoCombiTrans( 0, 0, 0,
5594 new TGeoRotation("",-90, 90, 90) ) );
5595 cableTrayA->AddNode(AlOutputCabs,1,
5596 new TGeoCombiTrans( 0, 0, 0,
5597 new TGeoRotation("",-90, 90, 90) ) );
5598 cableTrayA->AddNode(KaptonOutputCabs,1,
5599 new TGeoCombiTrans( 0, 0, 0,
5600 new TGeoRotation("",-90, 90, 90) ) );
5601 cableTrayA->AddNode(POLYAXOutputCabs,1,
5602 new TGeoCombiTrans( 0, 0, 0,
5603 new TGeoRotation("",-90, 90, 90) ) );
5604
5605
5606 // Finally put everything in the mother volume
798b4e0c 5607 Double_t rforw = kTrayARTrans + kExternTrayTotalHeight +
5608 kExternCoverSideThick -
5609 kForwardTrayTailHeight;
5610
5611 alpharot = -kTrayAFirstRotAng;
5612 xloc = rforw*SinD(alpharot);
5613 yloc = rforw*CosD(alpharot);
5614 zloc = kTrayAZTrans + kTrayAZToSupportRing - kForwardTrayUpperLength;
5615
57126ea1 5616 moth->AddNode(cableTrayA,1,
798b4e0c 5617 new TGeoCombiTrans( xloc, yloc, zloc,
5618 new TGeoRotation("",-alpharot,0,0) ) );
5619
5620 alpharot += 180;
5621 xloc = rforw*SinD(alpharot);
5622 yloc = rforw*CosD(alpharot);
57126ea1 5623 moth->AddNode(cableTrayA,2,
798b4e0c 5624 new TGeoCombiTrans( xloc, yloc, zloc,
5625 new TGeoRotation("",-alpharot,0,0) ) );
5626
5627 alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng;
5628 xloc = rforw*SinD(alpharot);
5629 yloc = rforw*CosD(alpharot);
57126ea1 5630 moth->AddNode(cableTrayA,3,
798b4e0c 5631 new TGeoCombiTrans( xloc, yloc, zloc,
5632 new TGeoRotation("",-alpharot,0,0) ) );
5633
5634 alpharot += 180;
5635 xloc = rforw*SinD(alpharot);
5636 yloc = rforw*CosD(alpharot);
57126ea1 5637 moth->AddNode(cableTrayA,4,
798b4e0c 5638 new TGeoCombiTrans( xloc, yloc, zloc,
5639 new TGeoRotation("",-alpharot,0,0) ) );
5640
5641
5642 return;
5643}
5644
aa177c73 5645//______________________________________________________________________
5646void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth,
5647 TGeoManager *mgr){
5648//
5649// Creates the SDD cable trays which are outside the ITS support cones
5650// but still inside the TPC on Side C
5651// (part of this code is taken or anyway inspired to ServicesCableSupport
5652// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
5653//
5654// Input:
5655// moth : the TGeoVolume owing the volume structure
5656// mgr : the GeoManager (default gGeoManager)
5657// Output:
5658//
5659// Created: ??? Bjorn S. Nilsen
5660// Updated: 17 Apr 2010 Mario Sitta
5661//
5662// Technical data are taken from AutoCAD drawings and other (oral)
5663// information given by F.Tosello
5664//
5665
57126ea1 5666 // Dimensions and positions of the C-Side Cable Tray
5667 // (Change accordingly to CreateSDDSSDTraysSideC !)
aa177c73 5668 const Int_t kNumTraySideC = 4;
5669
57126ea1 5670 const Double_t kSideCHalfThick = 0.100 *fgkcm;
5671 const Double_t kSideCLength1 = 172.800 *fgkcm;
5672 const Double_t kSideCLength2 = 189.300 *fgkcm;
5673 const Double_t kBarCoolRmax = 0.4 *fgkcm;
5674 const Double_t kXShiftBarCool = 13.00 *fgkcm;
5675
aa177c73 5676 const Double_t kSideCFoldAngle = 5.00 *fgkDegree;
5677
57126ea1 5678 // Dimensions and positions of the Cable Tray elements
5679 const Double_t kSideCCoolManifHalfX = 4.25 *fgkcm;
5680 const Double_t kSideCCoolManifHalfY = 4.03 *fgkcm;
5681 const Double_t kSideCCoolManifHalfZ = 2.17 *fgkcm;
5682 const Double_t kSideCCoolManifPOMFrac = 0.0051;
5683 const Double_t kSideCCoolManifSteelFrac= 0.8502;
5684 const Double_t kSideCCoolManifWaterFrac= 0.0868;
5685 const Double_t kSideCCoolManifAlFrac = 0.0579;
5686
5687 const Double_t kSideCCoolTubesHigh = 1.88 *fgkcm;
5688 const Double_t kSideCCoolTubesTrans = 0.85 *fgkcm;
5689 const Double_t kSideCCoolTubesPURFrac = 0.5884;
5690 const Double_t kSideCCoolTubesWaterFrac= 0.4114;
5691 const Double_t kSideCCoolTubesAirFrac = 0.0002;
5692
5693 const Double_t kSideCOptConnHalfX = 0.90 *fgkcm;
5694 const Double_t kSideCOptConnHalfZ = 1.37 *fgkcm;
5695 const Double_t kSideCOptConnPBTFrac = 0.6798;
5696 const Double_t kSideCOptConnSteelFrac = 0.2421;
5697 const Double_t kSideCOptConnAlFrac = 0.0781;
5698
5699 const Double_t kSideCOptFibsWide = 0.71 *fgkcm;
5700 const Double_t kSideCOptFibsHigh = 3.20 *fgkcm;
5701 const Double_t kSideCOptFibsTrans = 0.20 *fgkcm;
5702
5703 const Double_t kSideCInputCablesLen = 31.45 *fgkcm;
5704 const Double_t kSideCInputCablesWide = 12.50 *fgkcm;
5705 const Double_t kSideCInputCablesHigh = 0.95 *fgkcm;
5706 const Double_t kSideCInputCablesTrans = 1.15 *fgkcm;
5707 const Double_t kSideCInputCablesCu = 0.7405;
5708 const Double_t kSideCInputCablesPlast = 0.1268;
5709 const Double_t kSideCInputCablesAl = 0.0057;
5710 const Double_t kSideCInputCablesKapton = 0.0172;
5711 const Double_t kSideCInputCablesPOLYAX = 0.1098;
5712
5713 const Double_t kSideCOutputCablesX0 = 27.40 *fgkcm;
5714 const Double_t kSideCOutputCablesWide = 8.30 *fgkcm;
5715 const Double_t kSideCOutputCablesHigh = 1.18 *fgkcm;
5716 const Double_t kSideCOutputCablesCu = 0.6775;
5717 const Double_t kSideCOutputCablesPlast = 0.1613;
5718 const Double_t kSideCOutputCablesAl = 0.0078;
5719 const Double_t kSideCOutputCablesKapton= 0.0234;
5720 const Double_t kSideCOutputCablesPOLYAX= 0.1300;
5721
5722 const Double_t kSideCPCBBoardsHalfX = 6.30 *fgkcm;
5723 const Double_t kSideCPCBBoardsHalfY = 2.00 *fgkcm;
5724 const Double_t kSideCPCBBoardsHalfZ = 21.93 *fgkcm;
5725 const Double_t kSideCPCBBoardsCu = 0.3864;
5726 const Double_t kSideCPCBBoardsEpoxy = 0.1491;
5727 const Double_t kSideCPCBBoardsPlast = 0.0579;
5728 const Double_t kSideCPCBBoardsSteel = 0.1517;
5729 const Double_t kSideCPCBBoardsPPS = 0.2549;
5730
aa177c73 5731 // Overall position and rotation of the C-Side Cable Trays
5732 const Double_t kTraySideCRPos = 45.30 *fgkcm;
5733 const Double_t kTraySideCZPos = -102.40 *fgkcm;
5734 const Double_t kTraySideCAlphaRot[kNumTraySideC] = { -23.0, 59.0,
5735 /* from SSD tray position */ 180.-23.0, 180.+59.0};
5736
5737
5738 // Local variables
57126ea1 5739 Double_t xprof[6], yprof[6];
5740 Double_t height, xloc, yloc, zloc, alpharot, alphafold;
aa177c73 5741
5742
5743 // The assembly holding the metallic structure
57126ea1 5744 TGeoVolumeAssembly *trayStructure = CreateSDDSSDTraysSideC("ITSsupportSDDTrayC");
5745
5746 // Now the volumes inside it
5747 // The cooling manifold: four boxes
5748 // (X and Z are inverted on tray reference system)
5749 TGeoBBox *coolManifPOM = new TGeoBBox(kSideCCoolManifHalfZ,
5750 kSideCCoolManifPOMFrac*kSideCCoolManifHalfY,
5751 kSideCCoolManifHalfX);
5752
5753 TGeoBBox *coolManifSteel = new TGeoBBox(kSideCCoolManifHalfZ,
5754 kSideCCoolManifSteelFrac*kSideCCoolManifHalfY,
5755 kSideCCoolManifHalfX);
5756
5757 TGeoBBox *coolManifWater = new TGeoBBox(kSideCCoolManifHalfZ,
5758 kSideCCoolManifWaterFrac*kSideCCoolManifHalfY,
5759 kSideCCoolManifHalfX);
5760
5761 TGeoBBox *coolManifAl = new TGeoBBox(kSideCCoolManifHalfZ,
5762 kSideCCoolManifAlFrac*kSideCCoolManifHalfY,
5763 kSideCCoolManifHalfX);
5764
5765 // The cooling tubes: three Xtru's
5766 alpharot = kSideCFoldAngle*TMath::DegToRad();
5767
5768 TGeoXtru *coolTubesPUR = new TGeoXtru(2);
5769
5770 height = kSideCCoolTubesHigh*kSideCCoolTubesPURFrac;
5771
5772 xprof[0] = 2*kSideCCoolManifHalfZ;
5773 yprof[0] = 2*kSideCHalfThick + kSideCCoolTubesTrans;
5774 xprof[1] = kSideCLength1;
5775 yprof[1] = yprof[0];
5776 xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
5777 yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
5778 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
5779 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
5780 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5781 height, xprof[4], yprof[4]);
5782 xprof[5] = xprof[0];
5783 yprof[5] = yprof[0] + height;
5784
5785 coolTubesPUR->DefinePolygon(6, xprof, yprof);
5786 coolTubesPUR->DefineSection(0,-kSideCCoolManifHalfX);
5787 coolTubesPUR->DefineSection(1, kSideCCoolManifHalfX);
5788
5789 TGeoXtru *coolTubesWater = new TGeoXtru(2);
5790
5791 height = kSideCCoolTubesHigh*kSideCCoolTubesWaterFrac;
5792
5793 xprof[0] = coolTubesPUR->GetX(5);
5794 yprof[0] = coolTubesPUR->GetY(5);
5795 xprof[1] = coolTubesPUR->GetX(4);
5796 yprof[1] = coolTubesPUR->GetY(4);
5797 xprof[2] = coolTubesPUR->GetX(3);
5798 yprof[2] = coolTubesPUR->GetY(3);
5799 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
5800 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
5801 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5802 height, xprof[4], yprof[4]);
5803 xprof[5] = xprof[0];
5804 yprof[5] = yprof[0] + height;
5805
5806 coolTubesWater->DefinePolygon(6, xprof, yprof);
5807 coolTubesWater->DefineSection(0,-kSideCCoolManifHalfX);
5808 coolTubesWater->DefineSection(1, kSideCCoolManifHalfX);
5809
5810 TGeoXtru *coolTubesAir = new TGeoXtru(2);
5811
5812 height = kSideCCoolTubesHigh*kSideCCoolTubesAirFrac;
5813
5814 xprof[0] = coolTubesWater->GetX(5);
5815 yprof[0] = coolTubesWater->GetY(5);
5816 xprof[1] = coolTubesWater->GetX(4);
5817 yprof[1] = coolTubesWater->GetY(4);
5818 xprof[2] = coolTubesWater->GetX(3);
5819 yprof[2] = coolTubesWater->GetY(3);
5820 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
5821 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
5822 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5823 height, xprof[4], yprof[4]);
5824 xprof[5] = xprof[0];
5825 yprof[5] = yprof[0] + height;
5826
5827 coolTubesAir->DefinePolygon(6, xprof, yprof);
5828 coolTubesAir->DefineSection(0,-kSideCCoolManifHalfX);
5829 coolTubesAir->DefineSection(1, kSideCCoolManifHalfX);
5830
5831 // The optical fiber connectors: three boxes
5832 // (X and Z are inverted on tray reference system)
5833 TGeoBBox *optConnPBT = new TGeoBBox(kSideCOptConnHalfZ,
5834 kSideCOptConnPBTFrac*kSideCCoolManifHalfY,
5835 kSideCOptConnHalfX);
5836
5837 TGeoBBox *optConnSteel = new TGeoBBox(kSideCOptConnHalfZ,
5838 kSideCOptConnSteelFrac*kSideCCoolManifHalfY,
5839 kSideCOptConnHalfX);
5840
5841 TGeoBBox *optConnAl = new TGeoBBox(kSideCOptConnHalfZ,
5842 kSideCOptConnAlFrac*kSideCCoolManifHalfY,
5843 kSideCOptConnHalfX);
5844
5845 // The optical fibers: a Xtru
5846 TGeoXtru *opticalFibs = new TGeoXtru(2);
5847
5848 xprof[0] = 2*kSideCOptConnHalfZ;
5849 yprof[0] = 2*kSideCHalfThick + kSideCOptFibsTrans;
5850 xprof[1] = kSideCLength1;
5851 yprof[1] = yprof[0];
5852 xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
5853 yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
5854 xprof[3] = xprof[2] - kSideCOptFibsHigh*TMath::Sin(alpharot);
5855 yprof[3] = yprof[2] + kSideCOptFibsHigh*TMath::Cos(alpharot);
5856 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5857 kSideCOptFibsHigh, xprof[4], yprof[4]);
5858 xprof[5] = xprof[0];
5859 yprof[5] = yprof[0] + kSideCOptFibsHigh;
5860
5861 opticalFibs->DefinePolygon(6, xprof, yprof);
5862 opticalFibs->DefineSection(0,-kSideCOptFibsWide/2);
5863 opticalFibs->DefineSection(1, kSideCOptFibsWide/2);
5864
5865 // The input cables: five boxes
5866 // (X and Z are inverted on tray reference system)
5867 TGeoBBox *inputCabsCu = new TGeoBBox(kSideCInputCablesLen/2,
5868 kSideCInputCablesCu*kSideCInputCablesHigh/2,
5869 kSideCInputCablesWide/2);
5870
5871 TGeoBBox *inputCabsPlast = new TGeoBBox(kSideCInputCablesLen/2,
5872 kSideCInputCablesPlast*kSideCInputCablesHigh/2,
5873 kSideCInputCablesWide/2);
5874
5875 TGeoBBox *inputCabsAl = new TGeoBBox(kSideCInputCablesLen/2,
5876 kSideCInputCablesAl*kSideCInputCablesHigh/2,
5877 kSideCInputCablesWide/2);
5878
5879 TGeoBBox *inputCabsKapton = new TGeoBBox(kSideCInputCablesLen/2,
5880 kSideCInputCablesKapton*kSideCInputCablesHigh/2,
5881 kSideCInputCablesWide/2);
5882
5883 TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideCInputCablesLen/2,
5884 kSideCInputCablesPOLYAX*kSideCInputCablesHigh/2,
5885 kSideCInputCablesWide/2);
5886
5887 // The output cables: five Xtru
5888 TGeoXtru *outputCabsCu = new TGeoXtru(2);
5889
5890 height = kSideCOutputCablesCu*kSideCOutputCablesHigh;
5891
5892 xprof[0] = coolTubesAir->GetX(5) + kSideCOutputCablesX0;
5893 yprof[0] = coolTubesAir->GetY(5);
5894 xprof[1] = coolTubesAir->GetX(4);
5895 yprof[1] = coolTubesAir->GetY(4);
5896 xprof[2] = coolTubesAir->GetX(3);
5897 yprof[2] = coolTubesAir->GetY(3);
5898 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
5899 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
5900 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5901 height, xprof[4], yprof[4]);
5902 xprof[5] = xprof[0];
5903 yprof[5] = yprof[0] + height;
5904
5905 outputCabsCu->DefinePolygon(6, xprof, yprof);
5906 outputCabsCu->DefineSection(0,-kSideCOutputCablesWide/2);
5907 outputCabsCu->DefineSection(1, kSideCOutputCablesWide/2);
5908
5909 TGeoXtru *outputCabsPlast = new TGeoXtru(2);
5910
5911 height = kSideCOutputCablesPlast*kSideCOutputCablesHigh;
5912
5913 xprof[0] = outputCabsCu->GetX(5);
5914 yprof[0] = outputCabsCu->GetY(5);
5915 xprof[1] = outputCabsCu->GetX(4);
5916 yprof[1] = outputCabsCu->GetY(4);
5917 xprof[2] = outputCabsCu->GetX(3);
5918 yprof[2] = outputCabsCu->GetY(3);
5919 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
5920 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
5921 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5922 height, xprof[4], yprof[4]);
5923 xprof[5] = xprof[0];
5924 yprof[5] = yprof[0] + height;
5925
5926 outputCabsPlast->DefinePolygon(6, xprof, yprof);
5927 outputCabsPlast->DefineSection(0,-kSideCOutputCablesWide/2);
5928 outputCabsPlast->DefineSection(1, kSideCOutputCablesWide/2);
5929
5930 TGeoXtru *outputCabsAl = new TGeoXtru(2);
5931
5932 height = kSideCOutputCablesAl*kSideCOutputCablesHigh;
5933
5934 xprof[0] = outputCabsPlast->GetX(5);
5935 yprof[0] = outputCabsPlast->GetY(5);
5936 xprof[1] = outputCabsPlast->GetX(4);
5937 yprof[1] = outputCabsPlast->GetY(4);
5938 xprof[2] = outputCabsPlast->GetX(3);
5939 yprof[2] = outputCabsPlast->GetY(3);
5940 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
5941 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
5942 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5943 height, xprof[4], yprof[4]);
5944 xprof[5] = xprof[0];
5945 yprof[5] = yprof[0] + height;
5946
5947 outputCabsAl->DefinePolygon(6, xprof, yprof);
5948 outputCabsAl->DefineSection(0,-kSideCOutputCablesWide/2);
5949 outputCabsAl->DefineSection(1, kSideCOutputCablesWide/2);
5950
5951 TGeoXtru *outputCabsKapton = new TGeoXtru(2);
5952
5953 height = kSideCOutputCablesKapton*kSideCOutputCablesHigh;
5954
5955 xprof[0] = outputCabsAl->GetX(5);
5956 yprof[0] = outputCabsAl->GetY(5);
5957 xprof[1] = outputCabsAl->GetX(4);
5958 yprof[1] = outputCabsAl->GetY(4);
5959 xprof[2] = outputCabsAl->GetX(3);
5960 yprof[2] = outputCabsAl->GetY(3);
5961 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
5962 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
5963 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5964 height, xprof[4], yprof[4]);
5965 xprof[5] = xprof[0];
5966 yprof[5] = yprof[0] + height;
5967
5968 outputCabsKapton->DefinePolygon(6, xprof, yprof);
5969 outputCabsKapton->DefineSection(0,-kSideCOutputCablesWide/2);
5970 outputCabsKapton->DefineSection(1, kSideCOutputCablesWide/2);
5971
5972 TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
5973
5974 height = kSideCOutputCablesPOLYAX*kSideCOutputCablesHigh;
5975
5976 xprof[0] = outputCabsKapton->GetX(5);
5977 yprof[0] = outputCabsKapton->GetY(5);
5978 xprof[1] = outputCabsKapton->GetX(4);
5979 yprof[1] = outputCabsKapton->GetY(4);
5980 xprof[2] = outputCabsKapton->GetX(3);
5981 yprof[2] = outputCabsKapton->GetY(3);
5982 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
5983 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
5984 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5985 height, xprof[4], yprof[4]);
5986 xprof[5] = xprof[0];
5987 yprof[5] = yprof[0] + height;
5988
5989 outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
5990 outputCabsPOLYAX->DefineSection(0,-kSideCOutputCablesWide/2);
5991 outputCabsPOLYAX->DefineSection(1, kSideCOutputCablesWide/2);
5992
5993 // The PCB boards: five boxes
5994 // (X and Z are inverted on tray reference system)
5995 TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideCPCBBoardsHalfZ,
5996 kSideCPCBBoardsCu*kSideCPCBBoardsHalfY,
5997 kSideCPCBBoardsHalfX);
5998
5999 TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideCPCBBoardsHalfZ,
6000 kSideCPCBBoardsEpoxy*kSideCPCBBoardsHalfY,
6001 kSideCPCBBoardsHalfX);
6002
6003 TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideCPCBBoardsHalfZ,
6004 kSideCPCBBoardsPlast*kSideCPCBBoardsHalfY,
6005 kSideCPCBBoardsHalfX);
6006
6007 TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideCPCBBoardsHalfZ,
6008 kSideCPCBBoardsSteel*kSideCPCBBoardsHalfY,
6009 kSideCPCBBoardsHalfX);
6010
6011 TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideCPCBBoardsHalfZ,
6012 kSideCPCBBoardsPPS*kSideCPCBBoardsHalfY,
6013 kSideCPCBBoardsHalfX);
aa177c73 6014
6015
6016 // We have all shapes: now create the real volumes
57126ea1 6017 TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
6018 TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$");
6019 TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$");
6020 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
6021 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
6022 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
6023 TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
6024 TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
6025 TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
6026 TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$");
6027 TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
6028 TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$");
6029 TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$");
6030
6031 TGeoVolume *POMCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifPOM",
6032 coolManifPOM, medPOM);
6033
6034 POMCoolManif->SetVisibility(kTRUE);
6035 POMCoolManif->SetLineColor(kRed); // Red
6036 POMCoolManif->SetLineWidth(1);
6037 POMCoolManif->SetFillColor(POMCoolManif->GetLineColor());
6038 POMCoolManif->SetFillStyle(4000); // 0% transparent
6039
6040 TGeoVolume *SteelCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifSteel",
6041 coolManifSteel, medSteel);
6042
6043 SteelCoolManif->SetVisibility(kTRUE);
6044 SteelCoolManif->SetLineColor(kBlue); // Blue
6045 SteelCoolManif->SetLineWidth(1);
6046 SteelCoolManif->SetFillColor(SteelCoolManif->GetLineColor());
6047 SteelCoolManif->SetFillStyle(4000); // 0% transparent
6048
6049 TGeoVolume *WaterCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifWater",
6050 coolManifWater, medWater);
6051
6052 WaterCoolManif->SetVisibility(kTRUE);
6053 WaterCoolManif->SetLineColor(33); // Light Blue
6054 WaterCoolManif->SetLineWidth(1);
6055 WaterCoolManif->SetFillColor(WaterCoolManif->GetLineColor());
6056 WaterCoolManif->SetFillStyle(4000); // 0% transparent
6057
6058 TGeoVolume *AlCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifAl",
6059 coolManifAl, medAl);
6060
6061 AlCoolManif->SetVisibility(kTRUE);
6062 AlCoolManif->SetLineColor(6); // Purple
6063 AlCoolManif->SetLineWidth(1);
6064 AlCoolManif->SetFillColor(AlCoolManif->GetLineColor());
6065 AlCoolManif->SetFillStyle(4000); // 0% transparent
6066
6067 TGeoVolume *PURCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesPUR",
6068 coolTubesPUR, medPUR);
6069
6070 PURCoolTubes->SetVisibility(kTRUE);
6071 PURCoolTubes->SetLineColor(kRed); // Red
6072 PURCoolTubes->SetLineWidth(1);
6073 PURCoolTubes->SetFillColor(PURCoolTubes->GetLineColor());
6074 PURCoolTubes->SetFillStyle(4000); // 0% transparent
6075
6076 TGeoVolume *WaterCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesWater",
6077 coolTubesWater, medWater);
6078
6079 WaterCoolTubes->SetVisibility(kTRUE);
6080 WaterCoolTubes->SetLineColor(33); // Light Blue
6081 WaterCoolTubes->SetLineWidth(1);
6082 WaterCoolTubes->SetFillColor(WaterCoolTubes->GetLineColor());
6083 WaterCoolTubes->SetFillStyle(4000); // 0% transparent
6084
6085 TGeoVolume *AirCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesAir",
6086 coolTubesAir, medAir);
6087
6088 AirCoolTubes->SetVisibility(kTRUE);
6089 AirCoolTubes->SetLineColor(41);
6090 AirCoolTubes->SetLineWidth(1);
6091 AirCoolTubes->SetFillColor(AirCoolTubes->GetLineColor());
6092 AirCoolTubes->SetFillStyle(4000); // 0% transparent
6093
6094 TGeoVolume *PBTOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnPBT",
6095 optConnPBT, medPBT);
6096
6097 PBTOptConn->SetVisibility(kTRUE);
6098 PBTOptConn->SetLineColor(kRed); // Red
6099 PBTOptConn->SetLineWidth(1);
6100 PBTOptConn->SetFillColor(PBTOptConn->GetLineColor());
6101 PBTOptConn->SetFillStyle(4000); // 0% transparent
6102
6103 TGeoVolume *SteelOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnSteel",
6104 optConnSteel, medSteel);
6105
6106 SteelOptConn->SetVisibility(kTRUE);
6107 SteelOptConn->SetLineColor(kBlue); // Blue
6108 SteelOptConn->SetLineWidth(1);
6109 SteelOptConn->SetFillColor(SteelOptConn->GetLineColor());
6110 SteelOptConn->SetFillStyle(4000); // 0% transparent
6111
6112 TGeoVolume *AlOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnAl",
6113 optConnAl, medAl);
6114
6115 AlOptConn->SetVisibility(kTRUE);
6116 AlOptConn->SetLineColor(6); // Purple
6117 AlOptConn->SetLineWidth(1);
6118 AlOptConn->SetFillColor(AlOptConn->GetLineColor());
6119 AlOptConn->SetFillStyle(4000); // 0% transparent
6120
6121 TGeoVolume *OptFibs = new TGeoVolume("ITSsuppSDDSideCOptFibs",
6122 opticalFibs, medOptFib);
6123
6124 OptFibs->SetVisibility(kTRUE);
6125 OptFibs->SetLineColor(kOrange+2); // Orange
6126 OptFibs->SetLineWidth(1);
6127 OptFibs->SetFillColor(OptFibs->GetLineColor());
6128 OptFibs->SetFillStyle(4000); // 0% transparent
6129
6130 TGeoVolume *CuInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsCu",
6131 inputCabsCu, medCu);
6132
6133 CuInputCabs->SetVisibility(kTRUE);
6134 CuInputCabs->SetLineColor(kBlack); // Black
6135 CuInputCabs->SetLineWidth(1);
6136 CuInputCabs->SetFillColor(CuInputCabs->GetLineColor());
6137 CuInputCabs->SetFillStyle(4000); // 0% transparent
6138
6139 TGeoVolume *PlastInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPlast",
6140 inputCabsPlast, medPUR);
6141
6142 PlastInputCabs->SetVisibility(kTRUE);
6143 PlastInputCabs->SetLineColor(kRed); // Red
6144 PlastInputCabs->SetLineWidth(1);
6145 PlastInputCabs->SetFillColor(PlastInputCabs->GetLineColor());
6146 PlastInputCabs->SetFillStyle(4000); // 0% transparent
6147
6148 TGeoVolume *AlInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsAl",
6149 inputCabsAl, medAl);
6150
6151 AlInputCabs->SetVisibility(kTRUE);
6152 AlInputCabs->SetLineColor(6); // Purple
6153 AlInputCabs->SetLineWidth(1);
6154 AlInputCabs->SetFillColor(AlInputCabs->GetLineColor());
6155 AlInputCabs->SetFillStyle(4000); // 0% transparent
6156
6157 TGeoVolume *KaptonInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsKapton",
6158 inputCabsKapton, medKapton);
6159
6160 KaptonInputCabs->SetVisibility(kTRUE);
6161 KaptonInputCabs->SetLineColor(14); //
6162 KaptonInputCabs->SetLineWidth(1);
6163 KaptonInputCabs->SetFillColor(KaptonInputCabs->GetLineColor());
6164 KaptonInputCabs->SetFillStyle(4000); // 0% transparent
6165
6166 TGeoVolume *POLYAXInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPOLYAX",
6167 inputCabsPOLYAX, medPOLYAX);
6168
6169 POLYAXInputCabs->SetVisibility(kTRUE);
6170 POLYAXInputCabs->SetLineColor(34); //
6171 POLYAXInputCabs->SetLineWidth(1);
6172 POLYAXInputCabs->SetFillColor(POLYAXInputCabs->GetLineColor());
6173 POLYAXInputCabs->SetFillStyle(4000); // 0% transparent
6174
6175 TGeoVolume *CuOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsCu",
6176 outputCabsCu, medCu);
6177
6178 CuOutputCabs->SetVisibility(kTRUE);
6179 CuOutputCabs->SetLineColor(kBlack); // Black
6180 CuOutputCabs->SetLineWidth(1);
6181 CuOutputCabs->SetFillColor(CuOutputCabs->GetLineColor());
6182 CuOutputCabs->SetFillStyle(4000); // 0% transparent
6183
6184 TGeoVolume *PlastOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPlast",
6185 outputCabsPlast, medPUR);
6186
6187 PlastOutputCabs->SetVisibility(kTRUE);
6188 PlastOutputCabs->SetLineColor(kRed); // Red
6189 PlastOutputCabs->SetLineWidth(1);
6190 PlastOutputCabs->SetFillColor(PlastOutputCabs->GetLineColor());
6191 PlastOutputCabs->SetFillStyle(4000); // 0% transparent
6192
6193 TGeoVolume *AlOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsAl",
6194 outputCabsAl, medAl);
6195
6196 AlOutputCabs->SetVisibility(kTRUE);
6197 AlOutputCabs->SetLineColor(6); // Purple
6198 AlOutputCabs->SetLineWidth(1);
6199 AlOutputCabs->SetFillColor(AlOutputCabs->GetLineColor());
6200 AlOutputCabs->SetFillStyle(4000); // 0% transparent
6201
6202 TGeoVolume *KaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsKapton",
6203 outputCabsKapton, medKapton);
6204
6205 KaptonOutputCabs->SetVisibility(kTRUE);
6206 KaptonOutputCabs->SetLineColor(14); //
6207 KaptonOutputCabs->SetLineWidth(1);
6208 KaptonOutputCabs->SetFillColor(KaptonOutputCabs->GetLineColor());
6209 KaptonOutputCabs->SetFillStyle(4000); // 0% transparent
6210
6211 TGeoVolume *POLYAXOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPOLYAX",
6212 outputCabsPOLYAX, medPOLYAX);
6213
6214 POLYAXOutputCabs->SetVisibility(kTRUE);
6215 POLYAXOutputCabs->SetLineColor(34); //
6216 POLYAXOutputCabs->SetLineWidth(1);
6217 POLYAXOutputCabs->SetFillColor(POLYAXOutputCabs->GetLineColor());
6218 POLYAXOutputCabs->SetFillStyle(4000); // 0% transparent
6219
6220 TGeoVolume *CuPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsCu",
6221 pcbBoardsCu, medCu);
6222
6223 CuPCBBoards->SetVisibility(kTRUE);
6224 CuPCBBoards->SetLineColor(kBlack); // Black
6225 CuPCBBoards->SetLineWidth(1);
6226 CuPCBBoards->SetFillColor(CuPCBBoards->GetLineColor());
6227 CuPCBBoards->SetFillStyle(4000); // 0% transparent
6228
6229 TGeoVolume *EpoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsEpoxy",
6230 pcbBoardsEpoxy, medEpoxy);
6231
6232 EpoxyPCBBoards->SetVisibility(kTRUE);
6233 EpoxyPCBBoards->SetLineColor(22); //
6234 EpoxyPCBBoards->SetLineWidth(1);
6235 EpoxyPCBBoards->SetFillColor(EpoxyPCBBoards->GetLineColor());
6236 EpoxyPCBBoards->SetFillStyle(4000); // 0% transparent
6237
6238 TGeoVolume *PlastPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPlast",
6239 pcbBoardsPlast, medPUR);
6240
6241 PlastPCBBoards->SetVisibility(kTRUE);
6242 PlastPCBBoards->SetLineColor(kRed); // Red
6243 PlastPCBBoards->SetLineWidth(1);
6244 PlastPCBBoards->SetFillColor(PlastPCBBoards->GetLineColor());
6245 PlastPCBBoards->SetFillStyle(4000); // 0% transparent
6246
6247 TGeoVolume *SteelPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsSteel",
6248 pcbBoardsSteel, medSteel);
6249
6250 SteelPCBBoards->SetVisibility(kTRUE);
6251 SteelPCBBoards->SetLineColor(kBlue); // Blue
6252 SteelPCBBoards->SetLineWidth(1);
6253 SteelPCBBoards->SetFillColor(SteelPCBBoards->GetLineColor());
6254 SteelPCBBoards->SetFillStyle(4000); // 0% transparent
6255
6256 TGeoVolume *PPSPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPPS",
6257 pcbBoardsPPS, medPPS);
6258
6259 PPSPCBBoards->SetVisibility(kTRUE);
6260 PPSPCBBoards->SetLineColor(kGreen); // Green
6261 PPSPCBBoards->SetLineWidth(1);
6262 PPSPCBBoards->SetFillColor(PPSPCBBoards->GetLineColor());
6263 PPSPCBBoards->SetFillStyle(4000); // 0% transparent
6264
6265
6266 // Now fill the tray
6267 xloc = coolManifPOM->GetDX();
6268 yloc = 2*kSideCHalfThick + coolManifPOM->GetDY();
6269 trayStructure->AddNode(POMCoolManif, 1,
6270 new TGeoTranslation( xloc, yloc, 0) );
6271
6272 yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
6273 trayStructure->AddNode(SteelCoolManif, 1,
6274 new TGeoTranslation( xloc, yloc, 0) );
6275
6276 yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
6277 trayStructure->AddNode(WaterCoolManif, 1,
6278 new TGeoTranslation( xloc, yloc, 0) );
6279
6280 yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
6281 trayStructure->AddNode(AlCoolManif, 1,
6282 new TGeoTranslation( xloc, yloc, 0) );
6283
6284 xloc = inputCabsCu->GetDX();
6285 yloc += coolManifWater->GetDY() + inputCabsCu->GetDY()
6286 + kSideCInputCablesTrans;
6287 trayStructure->AddNode(CuInputCabs, 1,
6288 new TGeoTranslation( xloc, yloc, 0) );
6289
6290 yloc += inputCabsCu->GetDY() + inputCabsPlast->GetDY();
6291 trayStructure->AddNode(PlastInputCabs, 1,
6292 new TGeoTranslation( xloc, yloc, 0) );
6293
6294 yloc += inputCabsPlast->GetDY() + inputCabsAl->GetDY();
6295 trayStructure->AddNode(AlInputCabs, 1,
6296 new TGeoTranslation( xloc, yloc, 0) );
6297
6298 yloc += inputCabsAl->GetDY() + inputCabsKapton->GetDY();
6299 trayStructure->AddNode(KaptonInputCabs, 1,
6300 new TGeoTranslation( xloc, yloc, 0) );
6301
6302 yloc += inputCabsKapton->GetDY() + inputCabsPOLYAX->GetDY();
6303 trayStructure->AddNode(POLYAXInputCabs, 1,
6304 new TGeoTranslation( xloc, yloc, 0) );
6305
6306 trayStructure->AddNode(PURCoolTubes , 1, 0);
6307 trayStructure->AddNode(WaterCoolTubes, 1, 0);
6308 trayStructure->AddNode(AirCoolTubes , 1, 0);
6309
6310 xloc = optConnPBT->GetDX();
6311 yloc = 2*kSideCHalfThick + optConnPBT->GetDY();
6312 zloc = coolManifPOM->GetDZ() + optConnPBT->GetDZ();
6313 trayStructure->AddNode(PBTOptConn, 1,
6314 new TGeoTranslation( xloc, yloc, zloc) );
6315 trayStructure->AddNode(PBTOptConn, 2,
6316 new TGeoTranslation( xloc, yloc,-zloc) );
6317
6318 yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
6319 trayStructure->AddNode(SteelOptConn, 1,
6320 new TGeoTranslation( xloc, yloc, zloc) );
6321 trayStructure->AddNode(SteelOptConn, 2,
6322 new TGeoTranslation( xloc, yloc,-zloc) );
6323
6324 yloc += optConnSteel->GetDY() + optConnAl->GetDY();
6325 trayStructure->AddNode(AlOptConn, 1,
6326 new TGeoTranslation( xloc, yloc, zloc) );
6327 trayStructure->AddNode(AlOptConn, 2,
6328 new TGeoTranslation( xloc, yloc,-zloc) );
6329
6330 trayStructure->AddNode(OptFibs, 1,
6331 new TGeoTranslation( 0, 0, zloc) );
6332 trayStructure->AddNode(OptFibs, 2,
6333 new TGeoTranslation( 0, 0,-zloc) );
6334
6335 trayStructure->AddNode(CuOutputCabs , 1, 0);
6336 trayStructure->AddNode(PlastOutputCabs , 1, 0);
6337 trayStructure->AddNode(AlOutputCabs , 1, 0);
6338 trayStructure->AddNode(KaptonOutputCabs, 1, 0);
6339 trayStructure->AddNode(POLYAXOutputCabs, 1, 0);
6340
6341 xloc = kXShiftBarCool + kBarCoolRmax + pcbBoardsCu->GetDX();
6342 yloc = outputCabsPOLYAX->GetY(5) + pcbBoardsCu->GetDY();
6343 trayStructure->AddNode(CuPCBBoards, 1,
6344 new TGeoTranslation( xloc, yloc , 0) );
6345
6346 yloc += pcbBoardsCu->GetDY() + pcbBoardsEpoxy->GetDY();
6347 trayStructure->AddNode(EpoxyPCBBoards, 1,
6348 new TGeoTranslation( xloc, yloc , 0) );
6349
6350 yloc += pcbBoardsEpoxy->GetDY() + pcbBoardsPlast->GetDY();
6351 trayStructure->AddNode(PlastPCBBoards, 1,
6352 new TGeoTranslation( xloc, yloc , 0) );
6353
6354 yloc += pcbBoardsPlast->GetDY() + pcbBoardsSteel->GetDY();
6355 trayStructure->AddNode(SteelPCBBoards, 1,
6356 new TGeoTranslation( xloc, yloc , 0) );
6357
6358 yloc += pcbBoardsSteel->GetDY() + pcbBoardsPPS->GetDY();
6359 trayStructure->AddNode(PPSPCBBoards, 1,
6360 new TGeoTranslation( xloc, yloc , 0) );
6361
aa177c73 6362
6363 // Finally put everything in the mother volume
6364 alphafold = kSideCFoldAngle;
6365
6366 for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
6367 alpharot = kTraySideCAlphaRot[jt];
6368 xloc = kTraySideCRPos*SinD(alpharot);
6369 yloc = kTraySideCRPos*CosD(alpharot);
57126ea1 6370 moth->AddNode(trayStructure,jt+1,
aa177c73 6371 new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
6372 new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
6373 }
6374
6375
6376 return;
6377}
6378
6379
798b4e0c 6380//______________________________________________________________________
6381void AliITSv11GeometrySupport::SSDCableTraysSideA(TGeoVolume *moth,
6382 TGeoManager *mgr){
6383//
6384// Creates the SSD cable trays which are outside the ITS support cones
6385// but still inside the TPC on Side A
6386// (part of this code is taken or anyway inspired to ServicesCableSupport
6387// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
6388//
6389// Input:
6390// moth : the TGeoVolume owing the volume structure
6391// mgr : the GeoManager (default gGeoManager)
6392// Output:
6393//
6394// Created: ??? Bjorn S. Nilsen
6395// Updated: 30 Dec 2009 Mario Sitta
6396//
6397// Technical data are taken from AutoCAD drawings, L.Simonetti technical
6398// drawings and other (oral) information given by F.Tosello and
6399// Ton van den Brink
6400// Cables and cooling tubes are approximated with proper materials and
6401// rectangular cross sections, always preserving the total material budget.
6402//
6403
6404 // Dimensions and positions of the A-Side Cable Trays
6405 // (parts of 0872/G/D)
573a206f 6406 const Double_t kTrayARTrans = 408.35 *fgkmm;
798b4e0c 6407 const Double_t kTrayAZTrans = 1011.00 *fgkmm;
6408 const Double_t kForwardSideYTrans = 12.00 *fgkmm;//!!!TO BE CHECKED!!!
6409 const Double_t kCoversYTrans = 2.00 *fgkmm;
6410 const Double_t kTrayAZRot = (180-169.5);// Degrees
6411 const Double_t kTrayAFirstRotAng = 22.00; // Degrees
6412 const Double_t kTrayASecondRotAng = 15.00; // Degrees
6413
6414 const Double_t kTrayTotalHeight = 52.00 *fgkmm;
6415 const Double_t kTrayHeighToBend = 32.00 *fgkmm;
6416 const Double_t kTrayWidth = 130.00 *fgkmm;
6417 const Double_t kTrayThick = 2.00 *fgkmm;
6418
6419 const Double_t kTrayBendAngle = 22.00 *TMath::DegToRad();
6420
6421 const Double_t kForwardTrayTotalLen = 853.00 *fgkmm;
6422 const Double_t kForwardTrayFirstLen = 350.00 *fgkmm;
6423 const Double_t kForwardTrayFirstHeight = 47.00 *fgkmm;
6424 const Double_t kForwardCoverLen = 420.00 *fgkmm;
6425
6426 const Double_t kForwardSideLength = kForwardTrayFirstLen;//!!!TO BE CHECKED!!!
6427 const Double_t kForwardSideHeight = 90.00 *fgkmm;//!!!TO BE CHECKED!!!
6428 const Double_t kForwardSideThick = 1.00 *fgkmm;//!!!TO BE CHECKED!!!
6429 const Double_t kForwardCoverHeight = 10.00 *fgkmm;//!!!TO BE CHECKED!!!
6430
6431 const Double_t kExternalTrayTotalLen = 1200.00 *fgkmm;
6432 const Double_t kExternalCoverLen = kExternalTrayTotalLen;
6433 const Double_t kExternalCoverThick = 5.00 *fgkmm;
6434
6435 const Int_t kForwardTrayNpoints = 16;
6436
6437 const Double_t kServicesWidth = 100.00 *fgkmm;
6438 const Double_t kCopperHeight = 11.20 *fgkmm;// 1120 mm^2
6439 const Double_t kCablePlasticHeight = 11.50 *fgkmm;// 1150 mm^2
6440 const Double_t kCoolingWaterHeight = 2.65 *fgkmm;// 265 mm^2
6441 const Double_t kPoliUrethaneHeight = 4.62 *fgkmm;// 462 mm^2
6442
6443
6444 // Local variables
6445 Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
6446 Double_t xloc, yloc, zloc, alpharot, totalhi;
6447
6448
6449 // The two tray components as assemblies
573a206f 6450 TGeoVolumeAssembly *cableTrayAForw =
6451 new TGeoVolumeAssembly("ITSsupportSSDTrayAForw");
798b4e0c 6452 TGeoVolumeAssembly *cableTrayAExt =
6453 new TGeoVolumeAssembly("ITSsupportSSDTrayAExt");
6454
6455
6456 // First create all needed shapes
6457
6458 // The first part of the forward tray (part of 0872/G/D/07): a Xtru
6459 TGeoXtru *forwTrayPart1 = new TGeoXtru(2);
6460
6461 xprof[3] = kTrayWidth/2;
6462 yprof[3] = kForwardTrayFirstHeight;
6463 xprof[2] = xprof[3] - kTrayThick;
6464 yprof[2] = yprof[3];
6465 xprof[4] = xprof[3];
6466 yprof[4] = kTrayTotalHeight - kTrayHeighToBend;
6467 xprof[5] = xprof[4] - yprof[4]*TMath::Tan(kTrayBendAngle);
6468 yprof[5] = 0;
6469
6470 InsidePoint( xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
6471 -kTrayThick, xprof[1], yprof[1]);
6472
6473 xprof[6] = -xprof[5];
6474 yprof[6] = yprof[5];
6475
6476 InsidePoint( xprof[4], yprof[4], xprof[5], yprof[5], xprof[6], yprof[6],
6477 -kTrayThick, xprof[0], yprof[0]);
6478
6479 // We did the right side, now reflex on the left side
6480 for (Int_t jp = 0; jp < 6; jp++) {
6481 xprof[6+jp] = -xprof[5-jp];
6482 yprof[6+jp] = yprof[5-jp];
6483 }
6484
6485 // And now the actual Xtru
6486 forwTrayPart1->DefinePolygon(12, xprof, yprof);
6487 forwTrayPart1->DefineSection(0, 0);
6488 forwTrayPart1->DefineSection(1, kForwardTrayFirstLen);
6489
6490 // The second part of the forward tray (part of 0872/G/D/07): a Xtru
6491 TGeoXtru *forwTrayPart2 =
6492 CreateSDDSSDTraysSideA(kForwardTrayTotalLen - kForwardTrayFirstLen,
6493 kTrayTotalHeight);
6494
6495 // The external tray (as 0872/G/D/03): a Xtru with same profile
6496 TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternalTrayTotalLen,
6497 kTrayTotalHeight);
6498
6499 // The side wall of the forward tray: a BBox
6500 TGeoBBox *forwSide = new TGeoBBox(kForwardSideThick/2,
6501 kForwardSideHeight/2,
6502 kForwardSideLength/2);
6503
6504 // The side cover over the walls: a Xtru
6505 TGeoXtru *forwSideCover = new TGeoXtru(2);
6506 forwSideCover->SetName("ITSsuppSSDForwCover");
6507
6508 xprof[0] = kTrayWidth/2 + 2*kForwardSideThick;
6509 yprof[0] = kForwardCoverHeight;
6510 xprof[1] = xprof[0];
6511 yprof[1] = 0;
6512 xprof[2] = xprof[1] - kForwardSideThick;
6513 yprof[2] = yprof[1];
6514 xprof[3] = xprof[2];
6515 yprof[3] = yprof[0] - kForwardSideThick;
6516
6517 // We did the right side, now reflex on the left side
6518 for (Int_t jp = 0; jp < 4; jp++) {
6519 xprof[4+jp] = -xprof[3-jp];
6520 yprof[4+jp] = yprof[3-jp];
6521 }
6522
6523 forwSideCover->DefinePolygon(8, xprof, yprof);
6524 forwSideCover->DefineSection(0, 0);
6525 forwSideCover->DefineSection(1, kForwardSideLength);
6526
6527 // The forward and external covers: two Composite Shape's
6528 TGeoCompositeShape *forwardCover = CreateTrayAForwardCover(kForwardCoverLen);
6529
6530 TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternalCoverLen);
6531
6532 // The cable copper inside the forward tray: a BBox
6533 TGeoBBox *forwCopper = new TGeoBBox(kServicesWidth/2,
6534 kCopperHeight/2,
6535 kForwardTrayTotalLen/2);
6536
6537 // The cable copper inside the forward tray: a Xtru
6538 TGeoXtru *extCopper = new TGeoXtru(2);
6539 extCopper->SetName("ITSsuppSSDExtTrayCopper");
6540
6541 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
6542 - kTrayThick;
6543
6544 xprof[0] = -totalhi*TanD(kTrayAZRot);
6545 yprof[0] = kTrayThick;
6546 xprof[1] = kExternalTrayTotalLen;
6547 yprof[1] = yprof[0];
6548 xprof[2] = xprof[1];
6549 yprof[2] = yprof[1] + kCopperHeight;
6550 totalhi -= kCopperHeight;
6551 xprof[3] = -totalhi*TanD(kTrayAZRot);
6552 yprof[3] = yprof[2];
6553
6554 extCopper->DefinePolygon(4, xprof, yprof);
6555 extCopper->DefineSection(0, 0);
6556 extCopper->DefineSection(1, kServicesWidth);
6557
6558 // The cable plastic inside the forward tray: a BBox
6559 TGeoBBox *forwPlastic = new TGeoBBox(kServicesWidth/2,
6560 kCablePlasticHeight/2,
6561 kForwardTrayTotalLen/2);
6562
6563 // The cable plastic inside the forward tray: a Xtru
6564 TGeoXtru *extPlastic = new TGeoXtru(2);
6565 extPlastic->SetName("ITSsuppSSDExtTrayPlastic");
6566
6567 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
6568 - kTrayThick - kCopperHeight;
6569
6570 xprof[0] = -totalhi*TanD(kTrayAZRot);
6571 yprof[0] = kTrayThick;
6572 xprof[1] = kExternalTrayTotalLen;
6573 yprof[1] = yprof[0];
6574 xprof[2] = xprof[1];
6575 yprof[2] = yprof[1] + kCablePlasticHeight;
6576 totalhi -= kCablePlasticHeight;
6577 xprof[3] = -totalhi*TanD(kTrayAZRot);
6578 yprof[3] = yprof[2];
6579
6580 extPlastic->DefinePolygon(4, xprof, yprof);
6581 extPlastic->DefineSection(0, 0);
6582 extPlastic->DefineSection(1, kServicesWidth);
6583
6584 // The cooling water inside the forward tray: a BBox
6585 TGeoBBox *forwWater = new TGeoBBox(kServicesWidth/2,
6586 kCoolingWaterHeight/2,
6587 kForwardTrayTotalLen/2);
6588
6589 // The cooling water inside the forward tray: a Xtru
6590 TGeoXtru *extWater = new TGeoXtru(2);
6591 extWater->SetName("ITSsuppSSDExtTrayWater");
6592
6593 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
6594 - kTrayThick - kCopperHeight - kCablePlasticHeight;
6595
6596 xprof[0] = -totalhi*TanD(kTrayAZRot);
6597 yprof[0] = kTrayThick;
6598 xprof[1] = kExternalTrayTotalLen;
6599 yprof[1] = yprof[0];
6600 xprof[2] = xprof[1];
6601 yprof[2] = yprof[1] + kCoolingWaterHeight;
6602 totalhi -= kCoolingWaterHeight;
6603 xprof[3] = -totalhi*TanD(kTrayAZRot);
6604 yprof[3] = yprof[2];
6605
6606 extWater->DefinePolygon(4, xprof, yprof);
6607 extWater->DefineSection(0, 0);
6608 extWater->DefineSection(1, kServicesWidth);
6609
6610 // The polyurethane inside the forward tray: a BBox
6611 TGeoBBox *forwPUR = new TGeoBBox(kServicesWidth/2,
6612 kPoliUrethaneHeight/2,
6613 kForwardTrayTotalLen/2);
6614
6615 // The poliurethane inside the forward tray: a Xtru
6616 TGeoXtru *extPUR = new TGeoXtru(2);
6617 extPUR->SetName("ITSsuppSSDExtTrayPUR");
6618
6619 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
6620 - kTrayThick - kCopperHeight - kCablePlasticHeight
6621 - kCoolingWaterHeight;
6622
6623 xprof[0] = -totalhi*TanD(kTrayAZRot);
6624 yprof[0] = kTrayThick;
6625 xprof[1] = kExternalTrayTotalLen;
6626 yprof[1] = yprof[0];
6627 xprof[2] = xprof[1];
6628 yprof[2] = yprof[1] + kPoliUrethaneHeight;
6629 totalhi -= kPoliUrethaneHeight;
6630 xprof[3] = -totalhi*TanD(kTrayAZRot);
6631 yprof[3] = yprof[2];
6632
6633 extPUR->DefinePolygon(4, xprof, yprof);
6634 extPUR->DefineSection(0, 0);
6635 extPUR->DefineSection(1, kServicesWidth);
6636
6637
6638 // We have all shapes: now create the real volumes
6639 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
6640 TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
6641 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
6642 TGeoMedium *medFEP = mgr->GetMedium("ITS_SSD FEP$");
6643 TGeoMedium *medH2O = mgr->GetMedium("ITS_WATER$");
6644 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
6645
6646 TGeoVolume *forwTrayFirst = new TGeoVolume("ITSsuppSSDSideAForwTrayFirst",
6647 forwTrayPart1, medAl);
6648
6649 forwTrayFirst->SetVisibility(kTRUE);
6650 forwTrayFirst->SetLineColor(6); // Purple
6651 forwTrayFirst->SetLineWidth(1);
6652 forwTrayFirst->SetFillColor(forwTrayFirst->GetLineColor());
6653 forwTrayFirst->SetFillStyle(4000); // 0% transparent
6654
6655 TGeoVolume *forwTraySecond = new TGeoVolume("ITSsuppSSDSideAForwTraySecond",
6656 forwTrayPart2, medAl);
6657
6658 forwTraySecond->SetVisibility(kTRUE);
6659 forwTraySecond->SetLineColor(6); // Purple
6660 forwTraySecond->SetLineWidth(1);
6661 forwTraySecond->SetFillColor(forwTraySecond->GetLineColor());
6662 forwTraySecond->SetFillStyle(4000); // 0% transparent
6663
6664 TGeoVolume *forwTraySide = new TGeoVolume("ITSsuppSSDSideAForwTraySide",
6665 forwSide, medAl);
6666
6667 forwTraySide->SetVisibility(kTRUE);
6668 forwTraySide->SetLineColor(6); // Purple
6669 forwTraySide->SetLineWidth(1);
6670 forwTraySide->SetFillColor(forwTraySide->GetLineColor());
6671 forwTraySide->SetFillStyle(4000); // 0% transparent
6672
6673 TGeoVolume *forwTraySideCover = new TGeoVolume("ITSsuppSSDSideAForwTraySideCover",
6674 forwSideCover, medAl);
6675
6676 forwTraySideCover->SetVisibility(kTRUE);
6677 forwTraySideCover->SetLineColor(6); // Purple
6678 forwTraySideCover->SetLineWidth(1);
6679 forwTraySideCover->SetFillColor(forwTraySideCover->GetLineColor());
6680 forwTraySideCover->SetFillStyle(4000); // 0% transparent
6681
6682 TGeoVolume *externalTraySSD = new TGeoVolume("ITSsuppSSDSideAExternalTray",
6683 externalTray, medAl);
6684
6685 externalTraySSD->SetVisibility(kTRUE);
6686 externalTraySSD->SetLineColor(6); // Purple
6687 externalTraySSD->SetLineWidth(1);
6688 externalTraySSD->SetFillColor(externalTraySSD->GetLineColor());
6689 externalTraySSD->SetFillStyle(4000); // 0% transparent
6690
6691 TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSSDSideAForwTrayCover",
6692 forwardCover, medAntic);
6693
6694 forwardTrayCover->SetVisibility(kTRUE);
6695 forwardTrayCover->SetLineColor(kMagenta+1); // Purple
6696 forwardTrayCover->SetLineWidth(1);
6697 forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
6698 forwardTrayCover->SetFillStyle(4000); // 0% transparent
6699
6700 TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSSDSideAExtTrayCover",
6701 externCover, medAntic);
6702
6703 externTrayCover->SetVisibility(kTRUE);
6704 externTrayCover->SetLineColor(kMagenta+1); // Purple
6705 externTrayCover->SetLineWidth(1);
6706 externTrayCover->SetFillColor(externTrayCover->GetLineColor());
6707 externTrayCover->SetFillStyle(4000); // 0% transparent
6708
6709 TGeoVolume *forwCableCu = new TGeoVolume("ITSsuppSSDSideAForwCableCu",
6710 forwCopper, medCu);
6711
6712 forwCableCu->SetVisibility(kTRUE);
6713 forwCableCu->SetLineColor(kRed); // Red
6714 forwCableCu->SetLineWidth(1);
6715 forwCableCu->SetFillColor(forwCableCu->GetLineColor());
6716 forwCableCu->SetFillStyle(4000); // 0% transparent
6717
6718 TGeoVolume *extCableCu = new TGeoVolume("ITSsuppSSDSideAExtCableCu",
6719 extCopper, medCu);
6720
6721 extCableCu->SetVisibility(kTRUE);
6722 extCableCu->SetLineColor(kRed); // Red
6723 extCableCu->SetLineWidth(1);
6724 extCableCu->SetFillColor(extCableCu->GetLineColor());
6725 extCableCu->SetFillStyle(4000); // 0% transparent
6726
6727 TGeoVolume *forwCableFEP = new TGeoVolume("ITSsuppSSDSideAForwCableFEP",
6728 forwPlastic, medFEP);
6729
6730 forwCableFEP->SetVisibility(kTRUE);
6731 forwCableFEP->SetLineColor(kYellow); // Yellow
6732 forwCableFEP->SetLineWidth(1);
6733 forwCableFEP->SetFillColor(forwCableFEP->GetLineColor());
6734 forwCableFEP->SetFillStyle(4000); // 0% transparent
6735
6736 TGeoVolume *extCableFEP = new TGeoVolume("ITSsuppSSDSideAExtCableFEP",
6737 extPlastic, medFEP);
6738
6739 extCableFEP->SetVisibility(kTRUE);
6740 extCableFEP->SetLineColor(kYellow); // Yellow
6741 extCableFEP->SetLineWidth(1);
6742 extCableFEP->SetFillColor(extCableFEP->GetLineColor());
6743 extCableFEP->SetFillStyle(4000); // 0% transparent
6744
6745 TGeoVolume *forwTrayWater = new TGeoVolume("ITSsuppSSDSideAForwTrayWater",
6746 forwWater, medH2O);
6747
6748 forwTrayWater->SetVisibility(kTRUE);
6749 forwTrayWater->SetLineColor(kBlue); // Blue
6750 forwTrayWater->SetLineWidth(1);
6751 forwTrayWater->SetFillColor(forwTrayWater->GetLineColor());
6752 forwTrayWater->SetFillStyle(4000); // 0% transparent
6753
6754 TGeoVolume *extTrayWater = new TGeoVolume("ITSsuppSSDSideAExtTrayWater",
6755 extWater, medH2O);
6756
6757 extTrayWater->SetVisibility(kTRUE);
6758 extTrayWater->SetLineColor(kBlue); // Blue
6759 extTrayWater->SetLineWidth(1);
6760 extTrayWater->SetFillColor(extTrayWater->GetLineColor());
6761 extTrayWater->SetFillStyle(4000); // 0% transparent
6762
6763 TGeoVolume *forwPolyUr = new TGeoVolume("ITSsuppSSDSideAForwPolyUr",
6764 forwPUR, medPUR);
6765
6766 forwPolyUr->SetVisibility(kTRUE);
6767 forwPolyUr->SetLineColor(kGray); // Gray
6768 forwPolyUr->SetLineWidth(1);
6769 forwPolyUr->SetFillColor(forwPolyUr->GetLineColor());
6770 forwPolyUr->SetFillStyle(4000); // 0% transparent
6771
6772 TGeoVolume *extPolyUr = new TGeoVolume("ITSsuppSSDSideAExtPolyUr",
6773 extPUR, medPUR);
6774
6775 extPolyUr->SetVisibility(kTRUE);
6776 extPolyUr->SetLineColor(kGray); // Gray
6777 extPolyUr->SetLineWidth(1);
6778 extPolyUr->SetFillColor(extPolyUr->GetLineColor());
6779 extPolyUr->SetFillStyle(4000); // 0% transparent
6780
6781
6782 // Now build up the tray
573a206f 6783 cableTrayAForw->AddNode(forwTrayFirst, 1, 0);
798b4e0c 6784
573a206f 6785 cableTrayAForw->AddNode(forwTraySecond, 1,
798b4e0c 6786 new TGeoTranslation(0, 0, kForwardTrayFirstLen) );
6787
6788 xloc = kTrayWidth/2 + kForwardSideThick/2;
6789 yloc = kForwardTrayFirstHeight + kForwardSideHeight/2 - kForwardSideYTrans;
6790 zloc = kForwardSideLength/2;
573a206f 6791 cableTrayAForw->AddNode(forwTraySide,1,
798b4e0c 6792 new TGeoTranslation( xloc, yloc, zloc) );
573a206f 6793 cableTrayAForw->AddNode(forwTraySide,2,
798b4e0c 6794 new TGeoTranslation(-xloc, yloc, zloc) );
6795
6796 yloc = kForwardTrayFirstHeight + kForwardSideHeight - kForwardSideYTrans
6797 - kForwardCoverHeight;
573a206f 6798 cableTrayAForw->AddNode(forwTraySideCover,1,
798b4e0c 6799 new TGeoTranslation(0, yloc, 0) );
6800
6801 yloc = kTrayTotalHeight - kCoversYTrans;
6802 zloc = kForwardTrayTotalLen - kForwardCoverLen;
573a206f 6803 cableTrayAForw->AddNode(forwardTrayCover,1,
798b4e0c 6804 new TGeoTranslation(0, yloc, zloc) );
6805
6806 yloc = kTrayThick + forwCopper->GetDY();
6807 zloc = forwCopper->GetDZ();
573a206f 6808 cableTrayAForw->AddNode(forwCableCu, 1,
798b4e0c 6809 new TGeoTranslation(0, yloc, zloc) );
6810
6811 yloc = kTrayThick + kCopperHeight + forwPlastic->GetDY();
6812 zloc = forwPlastic->GetDZ();
573a206f 6813 cableTrayAForw->AddNode(forwCableFEP, 1,
798b4e0c 6814 new TGeoTranslation(0, yloc, zloc) );
6815
6816 yloc = kTrayThick + kCopperHeight + kCablePlasticHeight + forwWater->GetDY();
6817 zloc = forwWater->GetDZ();
573a206f 6818 cableTrayAForw->AddNode(forwTrayWater, 1,
798b4e0c 6819 new TGeoTranslation(0, yloc, zloc) );
6820
6821 yloc = kTrayThick + kCopperHeight + kCablePlasticHeight
6822 + kCoolingWaterHeight + forwPUR->GetDY();
6823 zloc = forwPUR->GetDZ();
573a206f 6824 cableTrayAForw->AddNode(forwPolyUr, 1,
798b4e0c 6825 new TGeoTranslation(0, yloc, zloc) );
6826
6827 // To simplify following placement in MARS, origin is on top
6828 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans;
6829
6830 yloc = -totalhi;
6831 cableTrayAExt->AddNode(externalTraySSD, 1,
6832 new TGeoTranslation(0, yloc, 0) );
6833
6834 yloc = -totalhi + kTrayTotalHeight - kCoversYTrans;
6835 cableTrayAExt->AddNode(externTrayCover,1,
6836 new TGeoTranslation(0, yloc, 0) );
6837
6838 xloc = extCopper->GetDZ();
6839 yloc = -totalhi;
6840 cableTrayAExt->AddNode(extCableCu,1,
6841 new TGeoCombiTrans( xloc, yloc, 0,
6842 new TGeoRotation("",-90, 90, 90) ) );
6843
6844 xloc = extPlastic->GetDZ();
6845 yloc = -totalhi + kCopperHeight;
6846 cableTrayAExt->AddNode(extCableFEP,1,
6847 new TGeoCombiTrans( xloc, yloc, 0,
6848 new TGeoRotation("",-90, 90, 90) ) );
6849
6850 xloc = extWater->GetDZ();
6851 yloc = -totalhi + kCopperHeight + kCablePlasticHeight;
6852 cableTrayAExt->AddNode(extTrayWater,1,
6853 new TGeoCombiTrans( xloc, yloc, 0,
6854 new TGeoRotation("",-90, 90, 90) ) );
6855
6856 xloc = extPUR->GetDZ();
6857 yloc = -totalhi + kCopperHeight + kCablePlasticHeight + kCoolingWaterHeight;
6858 cableTrayAExt->AddNode(extPolyUr,1,
6859 new TGeoCombiTrans( xloc, yloc, 0,
6860 new TGeoRotation("",-90, 90, 90) ) );
6861
6862
6863 // Finally put everything in the mother volume
6864 zloc = kTrayAZTrans;
6865 Double_t zlocext = zloc + kForwardTrayTotalLen;
6866 Double_t rExtTray = kTrayARTrans + kTrayTotalHeight;
6867
6868 alpharot = kTrayAFirstRotAng;
6869 xloc = kTrayARTrans*SinD(alpharot);
6870 yloc = kTrayARTrans*CosD(alpharot);
573a206f 6871 moth->AddNode(cableTrayAForw,1,
798b4e0c 6872 new TGeoCombiTrans( xloc, yloc, zloc,
6873 new TGeoRotation("",-alpharot,0,0) ) );
6874 xloc = rExtTray*SinD(alpharot);
6875 yloc = rExtTray*CosD(alpharot);
6876 moth->AddNode(cableTrayAExt,1,
6877 new TGeoCombiTrans( xloc, yloc, zlocext,
6878 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
6879
6880 alpharot += 180;
6881 xloc = kTrayARTrans*SinD(alpharot);
6882 yloc = kTrayARTrans*CosD(alpharot);
573a206f 6883 moth->AddNode(cableTrayAForw,2,
798b4e0c 6884 new TGeoCombiTrans( xloc, yloc, zloc,
6885 new TGeoRotation("",-alpharot,0,0) ) );
6886 xloc = rExtTray*SinD(alpharot);
6887 yloc = rExtTray*CosD(alpharot);
6888 moth->AddNode(cableTrayAExt,2,
6889 new TGeoCombiTrans( xloc, yloc, zlocext,
6890 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
6891
6892 alpharot = -kTrayAFirstRotAng - 2*kTrayASecondRotAng;
6893 xloc = kTrayARTrans*SinD(alpharot);
6894 yloc = kTrayARTrans*CosD(alpharot);
573a206f 6895 moth->AddNode(cableTrayAForw,3,
798b4e0c 6896 new TGeoCombiTrans( xloc, yloc, zloc,
6897 new TGeoRotation("",-alpharot,0,0) ) );
6898 xloc = rExtTray*SinD(alpharot);
6899 yloc = rExtTray*CosD(alpharot);
6900 moth->AddNode(cableTrayAExt,3,
6901 new TGeoCombiTrans( xloc, yloc, zlocext,
6902 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
6903
6904 alpharot += 180;
6905 xloc = kTrayARTrans*SinD(alpharot);
6906 yloc = kTrayARTrans*CosD(alpharot);
573a206f 6907 moth->AddNode(cableTrayAForw,4,
798b4e0c 6908 new TGeoCombiTrans( xloc, yloc, zloc,
6909 new TGeoRotation("",-alpharot,0,0) ) );
6910 xloc = rExtTray*SinD(alpharot);
6911 yloc = rExtTray*CosD(alpharot);
6912 moth->AddNode(cableTrayAExt,4,
6913 new TGeoCombiTrans( xloc, yloc, zlocext,
6914 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
6915
6916
6917 return;
6918}
6919
aa177c73 6920//______________________________________________________________________
6921void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth,
6922 TGeoManager *mgr){
6923//
6924// Creates the SSD cable trays which are outside the ITS support cones
6925// but still inside the TPC on Side C
6926// (part of this code is taken or anyway inspired to ServicesCableSupport
6927// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
6928//
6929// Input:
6930// moth : the TGeoVolume owing the volume structure
6931// mgr : the GeoManager (default gGeoManager)
6932// Output:
6933//
6934// Created: ??? Bjorn S. Nilsen
6935// Updated: 15 Apr 2010 Mario Sitta
6936//
6937// Technical data are taken from AutoCAD drawings and other (oral)
6938// information given by F.Tosello
6939//
6940
6941 // Dimensions and positions of the C-Side Cable Tray elements
6942 const Int_t kNumTraySideC = 4;
6943
6944 const Double_t kSideCFoldAngle = 5.00 *fgkDegree;
6945
6946 const Double_t kServicesWidth = 100.00 *fgkmm;
6947 const Double_t kCopperHeight = 11.20 *fgkmm;// 1120 mm^2
6948 const Double_t kCablePlasticHeight = 11.50 *fgkmm;// 1150 mm^2
6949 const Double_t kCoolingWaterHeight = 2.65 *fgkmm;// 265 mm^2
6950 const Double_t kPoliUrethaneHeight = 4.62 *fgkmm;// 462 mm^2
6951
6952 // Overall position and rotation of the C-Side Cable Trays
6953 const Double_t kTraySideCRPos = 45.30 *fgkcm;
6954 const Double_t kTraySideCZPos = -102.40 *fgkcm;
6955 const Double_t kTraySideCAlphaRot[kNumTraySideC] = { 23.0, -59.0,
6956 /* from Patch panel position */ 180.+23.0, 180.-59.0};
6957
6958
6959 // Local variables
6960 Double_t xprof[6], yprof[6];
6961 Double_t xloc, yloc, alpharot, alphafold;
6962
6963
6964 // The assembly holding the metallic structure
6965 TGeoVolumeAssembly *trayStructure =
6966 CreateSDDSSDTraysSideC("ITSsupportSSDTrayC");
6967
6968 // The cable copper inside the tray: a Xtru
6969 TGeoXtru *copper = new TGeoXtru(2);
6970 copper->SetName("ITSsuppSSDTrayCCopper");
6971
6972 // Copper lies on the lower plate: get position of its points
6973 TGeoXtru *lowerplate = (TGeoXtru*)(mgr->GetVolume("ITSsuppTraySideCLower")->GetShape());
6974 xprof[0] = lowerplate->GetX(5);
6975 yprof[0] = lowerplate->GetY(5);
6976 xprof[1] = lowerplate->GetX(4);
6977 yprof[1] = lowerplate->GetY(4);
6978 xprof[2] = lowerplate->GetX(3);
6979 yprof[2] = lowerplate->GetY(3);
6980 xprof[3] = xprof[2] - kCopperHeight*SinD(kSideCFoldAngle);
6981 yprof[3] = yprof[2] + kCopperHeight*CosD(kSideCFoldAngle);
6982 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6983 kCopperHeight , xprof[4], yprof[4]);
6984 xprof[5] = xprof[0];
6985 yprof[5] = yprof[0] + kCopperHeight;
6986
6987 copper->DefinePolygon(6, xprof, yprof);
6988 copper->DefineSection(0, -kServicesWidth/2);
6989 copper->DefineSection(1, kServicesWidth/2);
6990
6991 // The cable plastic inside the tray: a Xtru
6992 TGeoXtru *plastic = new TGeoXtru(2);
6993 plastic->SetName("ITSsuppSSDTrayCPlastic");
6994
6995 xprof[0] = copper->GetX(5);
6996 yprof[0] = copper->GetY(5);
6997 xprof[1] = copper->GetX(4);
6998 yprof[1] = copper->GetY(4);
6999 xprof[2] = copper->GetX(3);
7000 yprof[2] = copper->GetY(3);
7001 xprof[3] = xprof[2] - kCablePlasticHeight*SinD(kSideCFoldAngle);
7002 yprof[3] = yprof[2] + kCablePlasticHeight*CosD(kSideCFoldAngle);
7003 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7004 kCablePlasticHeight , xprof[4], yprof[4]);
7005 xprof[5] = xprof[0];
7006 yprof[5] = yprof[0] + kCablePlasticHeight;
7007
7008 plastic->DefinePolygon(6, xprof, yprof);
7009 plastic->DefineSection(0, -kServicesWidth/2);
7010 plastic->DefineSection(1, kServicesWidth/2);
7011
7012 // The cooling water inside the tray: a Xtru
7013 TGeoXtru *water = new TGeoXtru(2);
7014 water->SetName("ITSsuppSSDTrayCWater");
7015
7016 xprof[0] = plastic->GetX(5);
7017 yprof[0] = plastic->GetY(5);
7018 xprof[1] = plastic->GetX(4);
7019 yprof[1] = plastic->GetY(4);
7020 xprof[2] = plastic->GetX(3);
7021 yprof[2] = plastic->GetY(3);
7022 xprof[3] = xprof[2] - kCoolingWaterHeight*SinD(kSideCFoldAngle);
7023 yprof[3] = yprof[2] + kCoolingWaterHeight*CosD(kSideCFoldAngle);
7024 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7025 kCoolingWaterHeight , xprof[4], yprof[4]);
7026 xprof[5] = xprof[0];
7027 yprof[5] = yprof[0] + kCoolingWaterHeight;
7028
7029 water->DefinePolygon(6, xprof, yprof);
7030 water->DefineSection(0, -kServicesWidth/2);
7031 water->DefineSection(1, kServicesWidth/2);
7032
7033 // The poliurethane inside the tray: a Xtru
7034 TGeoXtru *PUR = new TGeoXtru(2);
7035 PUR->SetName("ITSsuppSSDTrayCPUR");
7036
7037 xprof[0] = water->GetX(5);
7038 yprof[0] = water->GetY(5);
7039 xprof[1] = water->GetX(4);
7040 yprof[1] = water->GetY(4);
7041 xprof[2] = water->GetX(3);
7042 yprof[2] = water->GetY(3);
7043 xprof[3] = xprof[2] - kPoliUrethaneHeight*SinD(kSideCFoldAngle);
7044 yprof[3] = yprof[2] + kPoliUrethaneHeight*CosD(kSideCFoldAngle);
7045 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7046 kPoliUrethaneHeight , xprof[4], yprof[4]);
7047 xprof[5] = xprof[0];
7048 yprof[5] = yprof[0] + kPoliUrethaneHeight;
7049
7050 PUR->DefinePolygon(6, xprof, yprof);
7051 PUR->DefineSection(0, -kServicesWidth/2);
7052 PUR->DefineSection(1, kServicesWidth/2);
7053
7054
7055 // We have all shapes: now create the real volumes
7056 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
7057 TGeoMedium *medFEP = mgr->GetMedium("ITS_SSD FEP$");
7058 TGeoMedium *medH2O = mgr->GetMedium("ITS_WATER$");
7059 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
7060
7061 TGeoVolume *copperCable = new TGeoVolume("ITSsuppSSDSideCCableCu",
7062 copper, medCu);
7063
7064 copperCable->SetVisibility(kTRUE);
7065 copperCable->SetLineColor(kRed); // Red
7066 copperCable->SetLineWidth(1);
7067 copperCable->SetFillColor(copperCable->GetLineColor());
7068 copperCable->SetFillStyle(4000); // 0% transparent
7069
7070 TGeoVolume *cableFEP = new TGeoVolume("ITSsuppSSDSideCCableFEP",
7071 plastic, medFEP);
7072
7073 cableFEP->SetVisibility(kTRUE);
7074 cableFEP->SetLineColor(kYellow); // Yellow
7075 cableFEP->SetLineWidth(1);
7076 cableFEP->SetFillColor(cableFEP->GetLineColor());
7077 cableFEP->SetFillStyle(4000); // 0% transparent
7078
7079 TGeoVolume *trayWater = new TGeoVolume("ITSsuppSSDSideCTrayWater",
7080 water, medH2O);
7081
7082 trayWater->SetVisibility(kTRUE);
7083 trayWater->SetLineColor(kBlue); // Blue
7084 trayWater->SetLineWidth(1);
7085 trayWater->SetFillColor(trayWater->GetLineColor());
7086 trayWater->SetFillStyle(4000); // 0% transparent
7087
7088 TGeoVolume *trayPolyUr = new TGeoVolume("ITSsuppSSDSideCPolyUr",
7089 PUR, medPUR);
7090
7091 trayPolyUr->SetVisibility(kTRUE);
7092 trayPolyUr->SetLineColor(kGray); // Gray
7093 trayPolyUr->SetLineWidth(1);
7094 trayPolyUr->SetFillColor(trayPolyUr->GetLineColor());
7095 trayPolyUr->SetFillStyle(4000); // 0% transparent
7096
7097
7098 // Now fill in the tray
7099 trayStructure->AddNode(copperCable,1,0);
7100 trayStructure->AddNode(cableFEP,1,0);
7101 trayStructure->AddNode(trayWater,1,0);
7102 trayStructure->AddNode(trayPolyUr,1,0);
7103
7104
7105 // Finally put everything in the mother volume
7106 alphafold = kSideCFoldAngle;
7107
7108 for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
7109 alpharot = kTraySideCAlphaRot[jt];
7110 xloc = kTraySideCRPos*SinD(alpharot);
7111 yloc = kTraySideCRPos*CosD(alpharot);
7112 moth->AddNode(trayStructure,jt+1,
7113 new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
7114 new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
7115 }
7116
7117
7118 return;
7119}
7120
798b4e0c 7121//______________________________________________________________________
57126ea1 7122void AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoVolumeAssembly *tray,
7123 TGeoManager *mgr){
798b4e0c 7124//
7125// Creates the forward SDD tray on Side A (0872/G/D/01)
7126//
7127// Input:
57126ea1 7128// tray : the TGeoVolumeAssembly to put the elements in
798b4e0c 7129// mgr : the GeoManager (used only to get the proper material)
7130//
7131// Output:
7132//
57126ea1 7133// Return:
798b4e0c 7134//
7135// Created: 08 Jan 2010 Mario Sitta
57126ea1 7136// Updated: 07 Sep 2010 Mario Sitta
798b4e0c 7137//
7138// Technical data are taken from AutoCAD drawings, L.Simonetti technical
7139// drawings and other (oral) information given by F.Tosello
7140//
7141
7142 // Dimensions of the A-Side Forward Cable Tray (0872/G/D/01)
7143 const Double_t kForwardTrayThick = 2.00 *fgkmm;
7144 const Double_t kForwardTraySideLength = 823.00 *fgkmm;
7145 const Double_t kForwardTrayTailLength = 212.00 *fgkmm;
7146 const Double_t kForwardTrayBaseHalfWide = 55.00 *fgkmm;
7147 const Double_t kForwardTrayNotchLength = 47.20 *fgkmm;
7148 const Double_t kForwardTrayNotchHeight = 25.00 *fgkmm;
7149 const Double_t kForwardTrayNotchDown = 10.00 *fgkmm;
7150 const Double_t kForwardTraySide1Height = 39.00 *fgkmm;
7151 const Double_t kForwardTraySide2Height = 26.00 *fgkmm;
7152 const Double_t kForwardTraySide2Expand = 10.50 *fgkmm;
7153 const Double_t kForwardTraySide3TailLen = 418.00 *fgkmm;
7154 const Double_t kForwardTraySide3TailHi = 31.00 *fgkmm;
7155 const Double_t kForwardTraySide3HeadLen = 425.00 *fgkmm;
7156 const Double_t kForwardTraySide3HeadHi = 72.00 *fgkmm;
7157 const Double_t kForwardTrayHorWingWide = 10.50 *fgkmm;
7158 const Double_t kForwardTrayVertWingWide = 15.00 *fgkmm;
7159
7160 const Int_t kForwardTraySideNpoints = 9;
7161
7162
7163 // Local variables
7164 Double_t xprof[kForwardTraySideNpoints], yprof[kForwardTraySideNpoints];
7165 Double_t ylen, zlen;
7166 Double_t xloc, yloc, zloc;
7167
7168
7169 // The tray has a very complex shape, so it is made by assembling
57126ea1 7170 // different elements (with some small simplifications)
798b4e0c 7171
7172 // The tray base: a BBox
7173 zlen = (kForwardTraySideLength-kForwardTrayTailLength)/2;
7174 TGeoBBox *trayBase = new TGeoBBox(kForwardTrayBaseHalfWide,
7175 kForwardTrayThick/2, zlen);
7176
7177 // The first part of the side wall: a Xtru
7178 TGeoXtru *traySide1 = new TGeoXtru(2);
7179
7180 xprof[0] = 0;
7181 yprof[0] = kForwardTrayThick;
7182 xprof[1] = kForwardTraySideLength-kForwardTrayTailLength;
7183 yprof[1] = yprof[0];
7184 xprof[2] = kForwardTraySideLength;
7185 yprof[2] = kForwardTraySide1Height + kForwardTrayThick;
7186 xprof[3] = 0;
7187 yprof[3] = yprof[2];
7188
7189 traySide1->DefinePolygon(4, xprof, yprof);
7190 traySide1->DefineSection(0, 0);
7191 traySide1->DefineSection(1, kForwardTrayThick);
7192
7193 // The second part of the side wall: a Xtru
7194 TGeoXtru *traySide2 = new TGeoXtru(2);
7195
7196 xprof[0] = kForwardTrayBaseHalfWide - kForwardTrayThick;
7197 yprof[0] = traySide1->GetY(2);
7198 xprof[1] = kForwardTrayBaseHalfWide;
7199 yprof[1] = yprof[0];
7200 xprof[2] = xprof[1] + kForwardTraySide2Expand;
7201 yprof[2] = yprof[1] + kForwardTraySide2Height;
7202 xprof[3] = xprof[2] - kForwardTrayThick;
7203 yprof[3] = yprof[2];
7204
7205 traySide2->DefinePolygon(4, xprof, yprof);
7206 traySide2->DefineSection(0, 0);
7207 traySide2->DefineSection(1, kForwardTraySideLength);
7208
7209 // The third part of the side wall: a Xtru
7210 TGeoXtru *traySide3 = new TGeoXtru(2);
7211
7212 xprof[0] = 0;
7213 yprof[0] = traySide2->GetY(2);
7214 xprof[1] = kForwardTraySideLength;
7215 yprof[1] = yprof[0];
7216 xprof[2] = xprof[1];
7217 yprof[2] = yprof[1] + kForwardTraySide3TailHi - kForwardTrayThick;
7218 xprof[3] = xprof[2] - kForwardTraySide3TailLen - kForwardTrayThick;
7219 yprof[3] = yprof[2];
7220 xprof[4] = xprof[3];
7221 yprof[4] = yprof[3] + kForwardTraySide3HeadHi + kForwardTrayThick;
7222 xprof[5] = xprof[4] - kForwardTraySide3HeadLen;
7223 yprof[5] = yprof[4];
7224 xprof[6] = xprof[5];
7225 yprof[6] = yprof[5] - kForwardTrayNotchHeight;
7226 xprof[7] = xprof[6] + kForwardTrayNotchLength;
7227 yprof[7] = yprof[6];
7228 xprof[8] = xprof[7];
7229 yprof[8] = yprof[7] - kForwardTrayNotchDown;
7230
7231 traySide3->DefinePolygon(9, xprof, yprof);
7232 traySide3->DefineSection(0, 0);
7233 traySide3->DefineSection(1, kForwardTrayThick);
7234
7235 // The horizontal wing: a BBox
7236 TGeoBBox *trayHorWing = new TGeoBBox(kForwardTrayHorWingWide/2,
7237 kForwardTrayThick/2,
7238 kForwardTraySide3TailLen/2);
7239
7240 // The vertical wing: a BBox
7241 ylen = (traySide3->GetY(4) - traySide3->GetY(3))/2;
7242 TGeoBBox *trayVertWing = new TGeoBBox(kForwardTrayVertWingWide/2,
7243 ylen, kForwardTrayThick/2);
7244
7245
7246 // We have all shapes: now create the real volumes
7247 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
7248
7249 TGeoVolume *forwTrayBase = new TGeoVolume("ITSsuppSDDSideAForwTrayBase",
7250 trayBase, medAl);
7251
7252 forwTrayBase->SetVisibility(kTRUE);
7253 forwTrayBase->SetLineColor(6); // Purple
7254 forwTrayBase->SetLineWidth(1);
7255 forwTrayBase->SetFillColor(forwTrayBase->GetLineColor());
7256 forwTrayBase->SetFillStyle(4000); // 0% transparent
7257
7258 TGeoVolume *forwTraySide1 = new TGeoVolume("ITSsuppSDDSideAForwTraySide1",
7259 traySide1, medAl);
7260
7261 forwTraySide1->SetVisibility(kTRUE);
7262 forwTraySide1->SetLineColor(6); // Purple
7263 forwTraySide1->SetLineWidth(1);
7264 forwTraySide1->SetFillColor(forwTraySide1->GetLineColor());
7265 forwTraySide1->SetFillStyle(4000); // 0% transparent
7266
7267 TGeoVolume *forwTraySide2 = new TGeoVolume("ITSsuppSDDSideAForwTraySide2",
7268 traySide2, medAl);
7269
7270 forwTraySide2->SetVisibility(kTRUE);
7271 forwTraySide2->SetLineColor(6); // Purple
7272 forwTraySide2->SetLineWidth(1);
7273 forwTraySide2->SetFillColor(forwTraySide2->GetLineColor());
7274 forwTraySide2->SetFillStyle(4000); // 0% transparent
7275
7276 TGeoVolume *forwTraySide3 = new TGeoVolume("ITSsuppSDDSideAForwTraySide3",
7277 traySide3, medAl);
7278
7279 forwTraySide3->SetVisibility(kTRUE);
7280 forwTraySide3->SetLineColor(6); // Purple
7281 forwTraySide3->SetLineWidth(1);
7282 forwTraySide3->SetFillColor(forwTraySide3->GetLineColor());
7283 forwTraySide3->SetFillStyle(4000); // 0% transparent
7284
7285 TGeoVolume *forwTrayHWing = new TGeoVolume("ITSsuppSDDSideAForwTrayHorWing",
7286 trayHorWing, medAl);
7287
7288 forwTrayHWing->SetVisibility(kTRUE);
7289 forwTrayHWing->SetLineColor(6); // Purple
7290 forwTrayHWing->SetLineWidth(1);
7291 forwTrayHWing->SetFillColor(forwTrayHWing->GetLineColor());
7292 forwTrayHWing->SetFillStyle(4000); // 0% transparent
7293
7294 TGeoVolume *forwTrayVWing = new TGeoVolume("ITSsuppSDDSideAForwTrayVertWing",
7295 trayVertWing, medAl);
7296
7297 forwTrayVWing->SetVisibility(kTRUE);
7298 forwTrayVWing->SetLineColor(6); // Purple
7299 forwTrayVWing->SetLineWidth(1);
7300 forwTrayVWing->SetFillColor(forwTrayVWing->GetLineColor());
7301 forwTrayVWing->SetFillStyle(4000); // 0% transparent
7302
7303
7304 // Now build up the tray
7305 yloc = kForwardTrayThick/2;
7306 zloc = zlen;
57126ea1 7307 tray->AddNode(forwTrayBase, 1,
7308 new TGeoTranslation(0, yloc, zloc) );
798b4e0c 7309
7310 xloc = kForwardTrayBaseHalfWide;
57126ea1 7311 tray->AddNode(forwTraySide1, 1,
7312 new TGeoCombiTrans(xloc, 0, 0,
798b4e0c 7313 new TGeoRotation("",90,-90,-90)));
7314 xloc = -xloc + kForwardTrayThick;
57126ea1 7315 tray->AddNode(forwTraySide1, 2,
7316 new TGeoCombiTrans(xloc, 0, 0,
798b4e0c 7317 new TGeoRotation("",90,-90,-90)));
7318
57126ea1 7319 tray->AddNode(forwTraySide2, 1, 0);
798b4e0c 7320 zloc = kForwardTraySideLength;
57126ea1 7321 tray->AddNode(forwTraySide2, 2,
7322 new TGeoCombiTrans(0, 0, zloc,
798b4e0c 7323 new TGeoRotation("",90,-180,-90)));
7324
7325 xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand;
57126ea1 7326 tray->AddNode(forwTraySide3, 1,
7327 new TGeoCombiTrans(xloc, 0, 0,
798b4e0c 7328 new TGeoRotation("",90,-90,-90)));
7329 xloc = -xloc + kForwardTrayThick;
57126ea1 7330 tray->AddNode(forwTraySide3, 2,
7331 new TGeoCombiTrans(xloc, 0, 0,
798b4e0c 7332 new TGeoRotation("",90,-90,-90)));
7333
7334 xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
7335 - kForwardTrayHorWingWide/2;
7336 yloc = traySide3->GetY(2) + kForwardTrayThick/2;
7337 zloc = kForwardTraySideLength - trayHorWing->GetDZ();
57126ea1 7338 tray->AddNode(forwTrayHWing, 1,
7339 new TGeoTranslation( xloc, yloc, zloc) );
7340 tray->AddNode(forwTrayHWing, 2,
7341 new TGeoTranslation(-xloc, yloc, zloc) );
798b4e0c 7342
7343 xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
7344 - kForwardTrayVertWingWide/2;
7345 yloc = traySide3->GetY(2) + trayVertWing->GetDY();
7346 zloc = traySide3->GetX(3) + kForwardTrayThick/2;
57126ea1 7347 tray->AddNode(forwTrayVWing, 1,
7348 new TGeoTranslation( xloc, yloc, zloc) );
7349 tray->AddNode(forwTrayVWing, 2,
7350 new TGeoTranslation(-xloc, yloc, zloc) );
798b4e0c 7351
7352
57126ea1 7353 return;
798b4e0c 7354}
7355
7356//______________________________________________________________________
7357TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAForwardCover(const Double_t coverLen){
7358//
7359// Creates the forward cover of the SDD and SSD cable trays on Side A
7360// (0872/G/D/02)
7361//
7362// Input:
7363// coverLen: the total length of the cover
7364//
7365// Output:
7366//
7367// Return: a TGeoCompositeShape for the cover
7368//
7369// Created: 03 Jan 2010 Mario Sitta
7370//
7371// Technical data are taken from AutoCAD drawings, L.Simonetti technical
7372// drawings and other (oral) information given by F.Tosello
7373//
7374
7375 // Dimensions and positions of the A-Side Cable Tray Forward Cover
7376 // (0872/G/D/02)
7377 const Double_t kForwardCoverWide = 130.00 *fgkmm;
7378 const Double_t kForwardCoverSideWide = 10.00 *fgkmm;
7379 const Double_t kForwardCoverHoleLen = 160.00 *fgkmm;
7380 const Double_t kForwardCoverHoleWide = 90.00 *fgkmm;
7381 const Double_t kForwardCoverHoleR10 = 10.00 *fgkmm;
7382 const Double_t kForwardCoverTotalThick = 5.00 *fgkmm;
7383 const Double_t kForwardCoverSideThick = 3.00 *fgkmm;
7384 const Double_t kForwardCoverInternThick = 2.00 *fgkmm;
7385
7386 const Double_t kForwardCoverHoleZTrans = 40.00 *fgkmm;
7387
7388
7389 // Local variables
7390 Double_t xprof[16], yprof[16];
7391 Double_t yloc, zloc;
7392
7393
7394 // The main shape: a Xtru
7395 TGeoXtru *forwCoverMain = new TGeoXtru(2);
7396 forwCoverMain->SetName("ITSsuppForwCoverMain");
7397
7398 xprof[0] = kForwardCoverWide/2;
7399 yprof[0] = kForwardCoverTotalThick;
7400 xprof[1] = xprof[0];
7401 yprof[1] = yprof[0] - kForwardCoverSideThick;
7402 xprof[2] = xprof[1] - kForwardCoverSideWide;
7403 yprof[2] = yprof[1];
7404 xprof[3] = xprof[2];
7405 yprof[3] = 0;
7406
7407 // We did the right side, now reflex on the left side
7408 for (Int_t jp = 0; jp < 4; jp++) {
7409 xprof[4+jp] = -xprof[3-jp];
7410 yprof[4+jp] = yprof[3-jp];
7411 }
7412
7413 // And now the actual Xtru
7414 forwCoverMain->DefinePolygon(8, xprof, yprof);
7415 forwCoverMain->DefineSection(0, 0);
7416 forwCoverMain->DefineSection(1, coverLen);
7417
7418 // The hole: another Xtru (rounded corners approximated with segments)
7419 TGeoXtru *forwCoverHole = new TGeoXtru(2);
7420 forwCoverHole->SetName("ITSsuppForwCoverHole");
7421
7422 CreateTrayACoverHolesShape(kForwardCoverHoleWide, kForwardCoverHoleLen,
7423 kForwardCoverHoleR10 , xprof, yprof);
7424
7425 // And now the actual Xtru
7426 forwCoverHole->DefinePolygon(16, xprof, yprof);
7427 forwCoverHole->DefineSection(0, 0);
7428 forwCoverHole->DefineSection(1, kForwardCoverTotalThick-kForwardCoverInternThick);
7429
7430 // Now the proper rototranslation matrices for the two holes
7431 yloc = kForwardCoverTotalThick-kForwardCoverInternThick-0.01;//Precision fix
7432 zloc = kForwardCoverHoleZTrans;
7433 TGeoCombiTrans *mf1 = new TGeoCombiTrans(0, yloc, zloc,
7434 new TGeoRotation("", 0, 90, 0) );
7435 mf1->SetName("mf1");
7436 mf1->RegisterYourself();
7437
7438 zloc = coverLen - kForwardCoverHoleZTrans - kForwardCoverHoleLen;
7439 TGeoCombiTrans *mf2 = new TGeoCombiTrans(0, yloc, zloc,
7440 new TGeoRotation("", 0, 90, 0) );
7441 mf2->SetName("mf2");
7442 mf2->RegisterYourself();
7443
7444 // Finally the actual cover shape
7445 TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppForwardCoverMain",
7446 "ITSsuppForwCoverMain-ITSsuppForwCoverHole:mf1-ITSsuppForwCoverHole:mf2");
7447
7448 return cover;
172b0d90 7449}
798b4e0c 7450
7451//______________________________________________________________________
7452TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAExternalCover(const Double_t coverLen){
7453//
7454// Creates the external cover of the SDD and SSD cable trays on Side A
7455// (0872/G/D/04)
7456//
7457// Input:
7458// coverLen: the total length of the cover
7459//
7460// Output:
7461//
7462// Return: a TGeoCompositeShape for the cover
7463//
7464// Created: 03 Jan 2010 Mario Sitta
7465//
7466// Technical data are taken from AutoCAD drawings, L.Simonetti technical
7467// drawings and other (oral) information given by F.Tosello
7468//
7469
7470 // Dimensions and positions of the A-Side Cable Tray External Cover
7471 // (0872/G/D/04)
7472 const Double_t kExternalCoverWide = 130.00 *fgkmm;
7473 const Double_t kExternalCoverSideWide = 10.00 *fgkmm;
7474 const Double_t kExternalCoverHoleLen1 = 262.00 *fgkmm;
7475 const Double_t kExternalCoverHoleLen2 = 280.00 *fgkmm;
7476 const Double_t kExternalCoverHoleLen3 = 205.00 *fgkmm;
7477 const Double_t kExternalCoverHoleLen4 = 55.00 *fgkmm;
7478 const Double_t kExternalCoverHoleWide = 90.00 *fgkmm;
7479 const Double_t kExternalCoverHoleR10 = 10.00 *fgkmm;
7480 const Double_t kExternalCoverTotalThick = 5.00 *fgkmm;
7481 const Double_t kExternalCoverSideThick = 3.00 *fgkmm;
7482 const Double_t kExternalCoverInternThick = 2.00 *fgkmm;
7483
7484 const Double_t kExternalCoverHole1ZTrans = 28.00 *fgkmm;
7485 const Double_t kExternalCoverHolesZTrans = 20.00 *fgkmm;
7486
7487
7488 // Local variables
7489 Double_t xprof[16], yprof[16];
7490 Double_t yloc, zloc;
7491
7492
7493 // The main shape: a Xtru
7494 TGeoXtru *externCoverMain = new TGeoXtru(2);
7495 externCoverMain->SetName("ITSsuppExternCoverMain");
7496
7497 xprof[0] = kExternalCoverWide/2;
7498 yprof[0] = kExternalCoverTotalThick;
7499 xprof[1] = xprof[0];
7500 yprof[1] = yprof[0] - kExternalCoverSideThick;
7501 xprof[2] = xprof[1] - kExternalCoverSideWide;
7502 yprof[2] = yprof[1];
7503 xprof[3] = xprof[2];
7504 yprof[3] = 0;
7505
7506 // We did the right side, now reflex on the left side
7507 for (Int_t jp = 0; jp < 4; jp++) {
7508 xprof[4+jp] = -xprof[3-jp];
7509 yprof[4+jp] = yprof[3-jp];
7510 }
7511
7512 // And now the actual Xtru
7513 externCoverMain->DefinePolygon(8, xprof, yprof);
7514 externCoverMain->DefineSection(0, 0);
7515 externCoverMain->DefineSection(1, coverLen);
7516
7517 // The first hole: a Xtru (rounded corners approximated with segments)
7518 Double_t holethick = kExternalCoverTotalThick-kExternalCoverInternThick;
7519
7520 TGeoXtru *extCoverHole1 = new TGeoXtru(2);
7521 extCoverHole1->SetName("ITSsuppExtCoverHole1");
7522
7523 CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen1,
7524 kExternalCoverHoleR10 , xprof, yprof);
7525
7526 extCoverHole1->DefinePolygon(16, xprof, yprof);
7527 extCoverHole1->DefineSection(0, 0);
7528 extCoverHole1->DefineSection(1, holethick);
7529
7530 // The second (and third) hole: another Xtru
7531 TGeoXtru *extCoverHole2 = new TGeoXtru(2);
7532 extCoverHole2->SetName("ITSsuppExtCoverHole2");
7533
7534 CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen2,
7535 kExternalCoverHoleR10 , xprof, yprof);
7536
7537 extCoverHole2->DefinePolygon(16, xprof, yprof);
7538 extCoverHole2->DefineSection(0, 0);
7539 extCoverHole2->DefineSection(1, holethick);
7540
7541 // The fourth hole: another Xtru
7542 TGeoXtru *extCoverHole3 = new TGeoXtru(2);
7543 extCoverHole3->SetName("ITSsuppExtCoverHole3");
7544
7545 CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen3,
7546 kExternalCoverHoleR10 , xprof, yprof);
7547
7548 extCoverHole3->DefinePolygon(16, xprof, yprof);
7549 extCoverHole3->DefineSection(0, 0);
7550 extCoverHole3->DefineSection(1, holethick);
7551
7552 // The fifth and last hole: another Xtru
7553 TGeoXtru *extCoverHole4 = new TGeoXtru(2);
7554 extCoverHole4->SetName("ITSsuppExtCoverHole4");
7555
7556 CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen4,
7557 kExternalCoverHoleR10 , xprof, yprof);
7558
7559 extCoverHole4->DefinePolygon(16, xprof, yprof);
7560 extCoverHole4->DefineSection(0, 0);
7561 extCoverHole4->DefineSection(1, holethick);
7562
7563 // Now the proper rototranslation matrices for the holes
7564 yloc = kExternalCoverTotalThick - kExternalCoverInternThick-0.01;
7565 zloc = kExternalCoverHole1ZTrans;
7566 TGeoCombiTrans *me1 = new TGeoCombiTrans(0, yloc, zloc,
7567 new TGeoRotation("", 0, 90, 0) );
7568 me1->SetName("me1");
7569 me1->RegisterYourself();
7570
7571 zloc += (kExternalCoverHoleLen1 + kExternalCoverHolesZTrans);
7572 TGeoCombiTrans *me2 = new TGeoCombiTrans(0, yloc, zloc,
7573 new TGeoRotation("", 0, 90, 0) );
7574 me2->SetName("me2");
7575 me2->RegisterYourself();
7576
7577 zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
7578 TGeoCombiTrans *me3 = new TGeoCombiTrans(0, yloc, zloc,
7579 new TGeoRotation("", 0, 90, 0) );
7580 me3->SetName("me3");
7581 me3->RegisterYourself();
7582
7583 zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
7584 TGeoCombiTrans *me4 = new TGeoCombiTrans(0, yloc, zloc,
7585 new TGeoRotation("", 0, 90, 0) );
7586 me4->SetName("me4");
7587 me4->RegisterYourself();
7588
7589 zloc += (kExternalCoverHoleLen3 + kExternalCoverHolesZTrans);
7590 TGeoCombiTrans *me5 = new TGeoCombiTrans(0, yloc, zloc,
7591 new TGeoRotation("", 0, 90, 0) );
7592 me5->SetName("me5");
7593 me5->RegisterYourself();
7594
7595 // Finally the actual cover shape
7596 TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppExternCoverMain",
7597 "ITSsuppExternCoverMain-ITSsuppExtCoverHole1:me1-ITSsuppExtCoverHole2:me2-ITSsuppExtCoverHole2:me3-ITSsuppExtCoverHole3:me4-ITSsuppExtCoverHole4:me5");
7598
7599 return cover;
7600}
7601
7602//______________________________________________________________________
7603void AliITSv11GeometrySupport::CreateTrayACoverHolesShape(const Double_t wide,
7604 const Double_t length, const Double_t r10,
7605 Double_t *x, Double_t *y){
7606//
7607// Creates the proper sequence of X and Y coordinates to determine
7608// the base XTru polygon for the holes in the SDD and SSD tray covers
7609// (here the rounded corners are approximated with segments)
7610//
7611// Input:
7612// wide : the hole wide
7613// length : the hole length
7614// r10 : the radius of the rounded corners
7615//
7616// Output:
7617// x, y : coordinate vectors [16]
7618//
7619// Created: 03 Jan 2010 Mario Sitta
7620//
7621// Caller must guarantee that x and y have the correct dimensions
7622// (but being this a private method it's easy to tell)
7623//
7624
7625 x[0] = wide/2 - r10;
7626 y[0] = length;
7627 x[1] = x[0] + r10*SinD(30);
7628 y[1] = y[0] - r10*(1 - CosD(30));
7629 x[2] = x[0] + r10*SinD(60);
7630 y[2] = y[0] - r10*(1 - CosD(60));
7631 x[3] = x[0] + r10;
7632 y[3] = y[0] - r10;
7633 x[4] = x[3];
7634 y[4] = r10;
7635 x[5] = x[4] - r10*(1 - CosD(30));
7636 y[5] = y[4] - r10*SinD(30);
7637 x[6] = x[4] - r10*(1 - CosD(60));
7638 y[6] = y[4] - r10*SinD(60);
7639 x[7] = x[4] - r10;
7640 y[7] = 0;
7641
7642 // We did the right side, now reflex on the left side
7643 for (Int_t jp = 0; jp < 8; jp++) {
7644 x[8+jp] = -x[7-jp];
7645 y[8+jp] = y[7-jp];
7646 }
7647
7648 return;
7649}
7650
7651//______________________________________________________________________
7652TGeoXtru* AliITSv11GeometrySupport::CreateSDDSSDTraysSideA(
7653 const Double_t trayLen,
7654 const Double_t trayHi){
7655//
7656// Creates parts of the SDD and SSD Trays on Side A which are identical
7657// (0872/G/D/03, part of 0872/G/D/07, 0872/G/C/11)
7658//
7659// Input:
7660// trayLen : the length of the tray part
7661// trayHi : the height of the tray part
7662//
7663// Output:
7664//
7665// Return: a TGeoXtru
7666//
7667// Created: 26 Feb 2010 Mario Sitta
7668//
7669// Technical data are taken from AutoCAD drawings, L.Simonetti technical
7670// drawings and other (oral) information given by F.Tosello
7671//
7672
7673 // Dimensions and positions of the A-Side Cable Trays
7674 // (parts of 0872/G/C)
7675 const Double_t kTrayWidth = 130.00 *fgkmm;
7676 const Double_t kTrayWingWidth = 10.00 *fgkmm;
7677 const Double_t kTrayHeightToBend = 20.00 *fgkmm;
7678 const Double_t kTrayThick = 2.00 *fgkmm;
7679
7680 const Double_t kTrayBendAngle = 22.00 *TMath::DegToRad();
7681
7682 const Int_t kTrayNpoints = 16;
7683
7684 // Local variables
7685 Double_t xprof[kTrayNpoints], yprof[kTrayNpoints];
7686
7687
7688 // The tray shape: a Xtru
7689 TGeoXtru *trayPart = new TGeoXtru(2);
7690
7691 xprof[2] = kTrayWidth/2 - kTrayThick;
7692 yprof[2] = trayHi - kTrayThick;
7693 xprof[3] = kTrayWidth/2 - kTrayWingWidth;
7694 yprof[3] = yprof[2];
7695 xprof[4] = xprof[3];
7696 yprof[4] = trayHi;
7697 xprof[5] = kTrayWidth/2;
7698 yprof[5] = yprof[4];
7699 xprof[6] = xprof[5];
7700 yprof[6] = kTrayHeightToBend;
7701 xprof[7] = xprof[6] - yprof[6]*TMath::Tan(kTrayBendAngle);
7702 yprof[7] = 0;
7703
7704 InsidePoint( xprof[5], yprof[5], xprof[6], yprof[6], xprof[7], yprof[7],
7705 -kTrayThick, xprof[1], yprof[1]);
7706
7707 xprof[8] = -xprof[7];
7708 yprof[8] = yprof[7];
7709
7710 InsidePoint( xprof[6], yprof[6], xprof[7], yprof[7], xprof[8], yprof[8],
7711 -kTrayThick, xprof[0], yprof[0]);
7712
7713 // We did the right side, now reflex on the left side
7714 for (Int_t jp = 0; jp < 8; jp++) {
7715 xprof[8+jp] = -xprof[7-jp];
7716 yprof[8+jp] = yprof[7-jp];
7717 }
7718
7719 // And now the actual Xtru
7720 trayPart->DefinePolygon(kTrayNpoints, xprof, yprof);
7721 trayPart->DefineSection(0, 0);
7722 trayPart->DefineSection(1, trayLen);
7723
7724
7725 return trayPart;
7726}
7727
aa177c73 7728//______________________________________________________________________
7729TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDSSDTraysSideC(
7730 const char *trayName,
7731 TGeoManager *mgr){
7732
7733//
7734// Creates the SDD and SSD Trays on Side C which are supposedly identical
7735//
7736// Input:
7737// trayName : the assembly name
7738//
7739// Output:
7740//
7741// Return: a TGeoVolumeAssembly
7742//
7743// Created: 16 Apr 2010 Mario Sitta
7744//
7745// Technical data are taken from AutoCAD drawings and other (oral)
7746// information given by F.Tosello
7747//
7748
7749 const Double_t kSideCHalfThick = 0.100 *fgkcm;
7750 const Double_t kSideCFoldAngle = 5.000 *TMath::DegToRad();
7751
7752 const Double_t kSideCLength1 = 172.800 *fgkcm;
7753 const Double_t kSideCLength2 = 189.300 *fgkcm;
7754 const Double_t kSideCHalfWide = 6.350 *fgkcm;
7755 const Double_t kSideCHeight1 = 11.800 *fgkcm;
7756 const Double_t kSideCHeight2 = 4.300 *fgkcm;
7757 const Double_t kSideCSideLength1 = 10.800 *fgkcm;
7758 const Double_t kSideCSideLength2 = 63.800 *fgkcm;
7759 const Double_t kSideCSideHeight = 8.800 *fgkcm;
7760 const Int_t kNPointsLowerFace = 6;
7761 const Int_t kNPointsLateralFace = 9;
7762
7763 const Double_t kSideCWingAHalfLen = 5.000 *fgkcm;
7764 const Double_t kSideCWingBHalfLen = 30.500 *fgkcm;
7765 const Double_t kSideCWingCHalfLen = 2.000 *fgkcm;
7766 const Double_t kSideCWingDHalfLen = 48.500 *fgkcm;
7767 const Double_t kSideCWingEHalfLen = 83.000 *fgkcm;
7768 const Double_t kSideCWingsHalfWide = 0.450 *fgkcm;
7769
7770 const Int_t kNPointsCoverFace = 12;
7771
7772 const Double_t kPlateHalfLen = 6.000 *fgkcm;
7773 const Double_t kPlateThick = 0.600 *fgkcm;
7774 const Double_t kPlateHeight = 4.200 *fgkcm;
7775 const Int_t kNPointsPlate = 6;
7776
7777 const Double_t kBarCoolRmax = 0.4 *fgkcm;
7778 const Int_t kNumBarCool = 2;
7779 const Double_t kXShiftBarCool[kNumBarCool] = { 8.7, 13.0 };
7780 const Double_t kYShiftBarCool[kNumBarCool] = { 8.5, 5.0 };
7781
7782
7783 // Local variables
7784 Double_t xprof[12], yprof[12];
7785 Double_t xloc, yloc, zloc, delta, alpharot;
7786
7787 // The single C-Side Cable tray as an assembly
7788 TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly(trayName);
7789
7790 // First create all needed shapes
7791
7792 // The Cable Tray lower face: a Xtru
7793 TGeoXtru *sideCLowerFace = new TGeoXtru(2);
7794
7795 xprof[0] = 0.;
7796 yprof[0] = 0.;
7797 xprof[1] = kSideCLength1;
7798 yprof[1] = 0.;
7799 xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle);
7800 yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle);
7801 xprof[3] = xprof[2] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle);
7802 yprof[3] = yprof[2] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle);
7803 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7804 2*kSideCHalfThick , xprof[4], yprof[4]);
7805 xprof[5] = 0.;
7806 yprof[5] = 2*kSideCHalfThick;
7807
7808 sideCLowerFace->DefinePolygon(kNPointsLowerFace, xprof, yprof);
7809 sideCLowerFace->DefineSection(0,-kSideCHalfWide);
7810 sideCLowerFace->DefineSection(1, kSideCHalfWide);
7811
7812 // The Cable Tray lateral face: a Xtru
7813 TGeoXtru *sideCLateralFace = new TGeoXtru(2);
7814
7815 xprof[0] = 0.;
7816 yprof[0] = 0.;
7817 xprof[1] = kSideCLength1;
7818 yprof[1] = 0.;
7819 xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle);
7820 yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle);
7821 xprof[3] = xprof[2] - kSideCHeight2*TMath::Sin(kSideCFoldAngle);
7822 yprof[3] = yprof[2] + kSideCHeight2*TMath::Cos(kSideCFoldAngle);
7823 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7824 kSideCHeight2, xprof[4], yprof[4]);
7825 xprof[5] = kSideCSideLength1 + kSideCSideLength2;
7826 yprof[5] = kSideCHeight2;
7827 xprof[6] = xprof[5];
7828 yprof[6] = kSideCSideHeight;
7829 xprof[7] = kSideCSideLength1;
7830 yprof[7] = kSideCHeight1;
7831 xprof[8] = 0;
7832 yprof[8] = yprof[7];
7833
7834 sideCLateralFace->DefinePolygon(kNPointsLateralFace, xprof, yprof);
7835 sideCLateralFace->DefineSection(0,-kSideCHalfThick);
7836 sideCLateralFace->DefineSection(1, kSideCHalfThick);
7837
7838 // The lateral wings: four BBox's
7839 TGeoBBox *sideCLateralWingA = new TGeoBBox(kSideCWingAHalfLen,
7840 kSideCHalfThick,
7841 kSideCWingsHalfWide);
7842
7843 TGeoBBox *sideCLateralWingB = new TGeoBBox(kSideCWingBHalfLen,
7844 kSideCHalfThick,
7845 kSideCWingsHalfWide);
7846
7847 TGeoBBox *sideCLateralWingC = new TGeoBBox(kSideCHalfThick, // With these
7848 kSideCWingCHalfLen, // X,Y avoid
7849 kSideCWingsHalfWide);//rotations
7850
7851 TGeoBBox *sideCLateralWingD = new TGeoBBox(kSideCWingDHalfLen,
7852 kSideCHalfThick,
7853 kSideCWingsHalfWide);
7854
7855 TGeoBBox *sideCLateralWingE = new TGeoBBox(kSideCWingEHalfLen,
7856 kSideCHalfThick,
7857 kSideCWingsHalfWide);
7858
7859 // The connecting lower plate: a Xtru
7860 TGeoXtru *sideCLowerPlate = new TGeoXtru(2);
7861
7862 xprof[0] = 0.;
7863 yprof[0] = 0.;
7864 xprof[1] = kPlateHalfLen;
7865 yprof[1] = 0.;
7866 xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle);
7867 yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle);
7868 xprof[3] = xprof[2] - kPlateThick*TMath::Sin(kSideCFoldAngle);
7869 yprof[3] = yprof[2] + kPlateThick*TMath::Cos(kSideCFoldAngle);
7870 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7871 kPlateThick, xprof[4], yprof[4]);
7872 xprof[5] = 0.;
7873 yprof[5] = kPlateThick;
7874
7875 sideCLowerPlate->DefinePolygon(kNPointsPlate, xprof, yprof);
7876 Double_t zwide = kSideCHalfWide + 2*kSideCHalfThick;
7877 sideCLowerPlate->DefineSection(0,-zwide);
7878 sideCLowerPlate->DefineSection(1, zwide);
7879
7880 // The connecting side plate: a Xtru
7881 TGeoXtru *sideCLateralPlate = new TGeoXtru(2);
7882
7883 xprof[0] = 0.;
7884 yprof[0] = 0.;
7885 xprof[1] = kPlateHalfLen;
7886 yprof[1] = 0.;
7887 xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle);
7888 yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle);
7889 xprof[3] = xprof[2] - kPlateHeight*TMath::Sin(kSideCFoldAngle);
7890 yprof[3] = yprof[2] + kPlateHeight*TMath::Cos(kSideCFoldAngle);
7891 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7892 kPlateHeight, xprof[4], yprof[4]); // Avoid small overlap
7893 xprof[5] = 0.;
7894 yprof[5] = kPlateHeight;
7895
7896 sideCLateralPlate->DefinePolygon(kNPointsPlate, xprof, yprof);
7897 sideCLateralPlate->DefineSection(0,-kPlateThick/2);
7898 sideCLateralPlate->DefineSection(1, kPlateThick/2);
7899
7900 // The bar fixing the cooling tubes: a Tube
7901 TGeoTube *coolBar = new TGeoTube(0., kBarCoolRmax, kSideCHalfWide);
7902
7903 // The Cable Tray cover: a (complex) Xtru
7904 TGeoXtru *sideCCoverFace = new TGeoXtru(2);
7905
7906 xprof[ 0] = sideCLateralFace->GetX(8);
7907 yprof[ 0] = sideCLateralFace->GetY(8);
7908 xprof[ 1] = sideCLateralFace->GetX(7);
7909 yprof[ 1] = sideCLateralFace->GetY(7);
7910 xprof[ 2] = sideCLateralFace->GetX(6);
7911 yprof[ 2] = sideCLateralFace->GetY(6);
7912 xprof[ 3] = sideCLateralFace->GetX(5);
7913 yprof[ 3] = sideCLateralFace->GetY(5);
7914 xprof[ 4] = sideCLateralFace->GetX(4);
7915 yprof[ 4] = sideCLateralFace->GetY(4);
7916
7917 xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2;
7918 delta = kSideCLength1 - (xloc + kSideCWingDHalfLen);
7919 xprof[ 5] = xprof[4]
7920 + (delta + 2*kSideCWingEHalfLen)*TMath::Cos(kSideCFoldAngle);
7921 yprof[ 5] = yprof[4]
7922 + (delta + 2*kSideCWingEHalfLen)*TMath::Sin(kSideCFoldAngle);
7923
7924 xprof[ 6] = xprof[5] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle);
7925 yprof[ 6] = yprof[5] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle);
7926 InsidePoint(xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
7927 2*kSideCHalfThick, xprof[7], yprof[7]);
7928 InsidePoint(xprof[2], yprof[2], xprof[3], yprof[3], xprof[4], yprof[4],
7929 2*kSideCHalfThick, xprof[8], yprof[8]);
7930 xprof[ 9] = xprof[2] + 2*kSideCHalfThick;
7931 yprof[ 9] = yprof[2] + 2*kSideCHalfThick;
7932 xprof[10] = xprof[1];
7933 yprof[10] = yprof[1] + 2*kSideCHalfThick;
7934 xprof[11] = xprof[0];
7935 yprof[11] = yprof[0] + 2*kSideCHalfThick;
7936
7937 sideCCoverFace->DefinePolygon(kNPointsCoverFace, xprof, yprof);
7938 zloc = kSideCHalfWide + 2*kSideCHalfThick + 2*kSideCWingsHalfWide;
7939 sideCCoverFace->DefineSection(0,-zloc);
7940 sideCCoverFace->DefineSection(1, zloc);
7941
7942
7943 // We have all shapes: now create the real volumes
7944 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
7945
7946 TGeoVolume *traySideCLowerFace = new TGeoVolume("ITSsuppTraySideCLower",
7947 sideCLowerFace, medAl);
7948
7949 traySideCLowerFace->SetVisibility(kTRUE);
7950 traySideCLowerFace->SetLineColor(6); // Purple
7951 traySideCLowerFace->SetLineWidth(1);
7952 traySideCLowerFace->SetFillColor(traySideCLowerFace->GetLineColor());
7953 traySideCLowerFace->SetFillStyle(4000); // 0% transparent
7954
7955 TGeoVolume *traySideCLateralFace = new TGeoVolume("ITSsuppTraySideCLateral",
7956 sideCLateralFace, medAl);
7957
7958 traySideCLateralFace->SetVisibility(kTRUE);
7959 traySideCLateralFace->SetLineColor(6); // Purple
7960 traySideCLateralFace->SetLineWidth(1);
7961 traySideCLateralFace->SetFillColor(traySideCLateralFace->GetLineColor());
7962 traySideCLateralFace->SetFillStyle(4000); // 0% transparent
7963
7964 TGeoVolume *traySideCLateralWingA =
7965 new TGeoVolume("ITSsuppTraySideCLateralWingA", sideCLateralWingA, medAl);
7966
7967 traySideCLateralWingA->SetVisibility(kTRUE);
7968 traySideCLateralWingA->SetLineColor(6); // Purple
7969 traySideCLateralWingA->SetLineWidth(1);
7970 traySideCLateralWingA->SetFillColor(traySideCLateralWingA->GetLineColor());
7971 traySideCLateralWingA->SetFillStyle(4000); // 0% transparent
7972
7973 TGeoVolume *traySideCLateralWingB =
7974 new TGeoVolume("ITSsuppTraySideCLateralWingB", sideCLateralWingB, medAl);
7975
7976 traySideCLateralWingB->SetVisibility(kTRUE);
7977 traySideCLateralWingB->SetLineColor(6); // Purple
7978 traySideCLateralWingB->SetLineWidth(1);
7979 traySideCLateralWingB->SetFillColor(traySideCLateralWingB->GetLineColor());
7980 traySideCLateralWingB->SetFillStyle(4000); // 0% transparent
7981
7982 TGeoVolume *traySideCLateralWingC =
7983 new TGeoVolume("ITSsuppTraySideCLateralWingC", sideCLateralWingC, medAl);
7984
7985 traySideCLateralWingC->SetVisibility(kTRUE);
7986 traySideCLateralWingC->SetLineColor(6); // Purple
7987 traySideCLateralWingC->SetLineWidth(1);
7988 traySideCLateralWingC->SetFillColor(traySideCLateralWingC->GetLineColor());
7989 traySideCLateralWingC->SetFillStyle(4000); // 0% transparent
7990
7991 TGeoVolume *traySideCLateralWingD =
7992 new TGeoVolume("ITSsuppTraySideCLateralWingD", sideCLateralWingD, medAl);
7993
7994 traySideCLateralWingD->SetVisibility(kTRUE);
7995 traySideCLateralWingD->SetLineColor(6); // Purple
7996 traySideCLateralWingD->SetLineWidth(1);
7997 traySideCLateralWingD->SetFillColor(traySideCLateralWingD->GetLineColor());
7998 traySideCLateralWingD->SetFillStyle(4000); // 0% transparent
7999
8000 TGeoVolume *traySideCLateralWingE =
8001 new TGeoVolume("ITSsuppTraySideCLateralWingE", sideCLateralWingE, medAl);
8002
8003 traySideCLateralWingE->SetVisibility(kTRUE);
8004 traySideCLateralWingE->SetLineColor(6); // Purple
8005 traySideCLateralWingE->SetLineWidth(1);
8006 traySideCLateralWingE->SetFillColor(traySideCLateralWingE->GetLineColor());
8007 traySideCLateralWingE->SetFillStyle(4000); // 0% transparent
8008
8009 TGeoVolume *traySideCLowerPlate =
8010 new TGeoVolume("ITSsuppTraySideCLowerPlate", sideCLowerPlate, medAl);
8011
8012 traySideCLowerPlate->SetVisibility(kTRUE);
8013 traySideCLowerPlate->SetLineColor(6); // Purple
8014 traySideCLowerPlate->SetLineWidth(1);
8015 traySideCLowerPlate->SetFillColor(traySideCLowerPlate->GetLineColor());
8016 traySideCLowerPlate->SetFillStyle(4000); // 0% transparent
8017
8018 TGeoVolume *traySideCLateralPlate =
8019 new TGeoVolume("ITSsuppTraySideCLateralPlate", sideCLateralPlate, medAl);
8020
8021 traySideCLateralPlate->SetVisibility(kTRUE);
8022 traySideCLateralPlate->SetLineColor(6); // Purple
8023 traySideCLateralPlate->SetLineWidth(1);
8024 traySideCLateralPlate->SetFillColor(traySideCLateralPlate->GetLineColor());
8025 traySideCLateralPlate->SetFillStyle(4000); // 0% transparent
8026
8027 TGeoVolume *traySideCCoverFace =
8028 new TGeoVolume("ITSsuppTraySideCCoverFace", sideCCoverFace, medAl);
8029
8030 traySideCCoverFace->SetVisibility(kTRUE);
8031 traySideCCoverFace->SetLineColor(6); // Purple
8032 traySideCCoverFace->SetLineWidth(1);
8033 traySideCCoverFace->SetFillColor(traySideCCoverFace->GetLineColor());
8034 traySideCCoverFace->SetFillStyle(4000); // 0% transparent
8035
8036 TGeoVolume *coolingTubeBar = new TGeoVolume("ITSsuppTraySideCCoolBar",
8037 coolBar, medAl);
8038
8039 coolingTubeBar->SetVisibility(kTRUE);
8040 coolingTubeBar->SetLineColor(6); // Purple
8041 coolingTubeBar->SetLineWidth(1);
8042 coolingTubeBar->SetFillColor(coolingTubeBar->GetLineColor());
8043 coolingTubeBar->SetFillStyle(4000); // 0% transparent
8044
8045
8046 // Now build up the tray
8047 cableTrayC->AddNode(traySideCLowerFace,1,0);
8048
8049 zloc = kSideCHalfWide + kSideCHalfThick;
8050 cableTrayC->AddNode(traySideCLateralFace,1,
8051 new TGeoTranslation(0., 0., zloc) );
8052 cableTrayC->AddNode(traySideCLateralFace,2,
8053 new TGeoTranslation(0., 0.,-zloc) );
8054
8055 xloc = kSideCWingAHalfLen;
8056 yloc = kSideCHeight1 - kSideCHalfThick;
8057 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8058 cableTrayC->AddNode(traySideCLateralWingA,1,
8059 new TGeoTranslation(xloc, yloc, zloc) );
8060 cableTrayC->AddNode(traySideCLateralWingA,2,
8061 new TGeoTranslation(xloc, yloc,-zloc) );
8062
8063 xloc = kSideCSideLength1 + kSideCSideLength2/2;
8064 yloc = Yfrom2Points(kSideCSideLength1,kSideCHeight1,
8065 kSideCSideLength1+kSideCSideLength2,kSideCSideHeight,
8066 xloc) - kSideCHalfThick -0.0012; // Avoid small overlap
8067 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8068 alpharot = (-(kSideCHeight1 - kSideCSideHeight)/kSideCSideLength2 )*
8069 TMath::RadToDeg();
8070 cableTrayC->AddNode(traySideCLateralWingB,1,
8071 new TGeoCombiTrans(xloc, yloc, zloc,
8072 new TGeoRotation("",alpharot,0,0) ) );
8073 cableTrayC->AddNode(traySideCLateralWingB,2,
8074 new TGeoCombiTrans(xloc, yloc,-zloc,
8075 new TGeoRotation("",alpharot,0,0) ) );
8076
8077 xloc = kSideCSideLength1 + kSideCSideLength2 - kSideCHalfThick;
8078 yloc = kSideCSideHeight - kSideCWingCHalfLen;
8079 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8080 cableTrayC->AddNode(traySideCLateralWingC,1,
8081 new TGeoTranslation(xloc, yloc, zloc) );
8082 cableTrayC->AddNode(traySideCLateralWingC,2,
8083 new TGeoTranslation(xloc, yloc,-zloc) );
8084
8085 xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2;
8086 yloc = kSideCHeight2 - kSideCHalfThick;
8087 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8088 cableTrayC->AddNode(traySideCLateralWingD,1,
8089 new TGeoTranslation(xloc, yloc, zloc) );
8090 cableTrayC->AddNode(traySideCLateralWingD,2,
8091 new TGeoTranslation(xloc, yloc,-zloc) );
8092
8093 delta = kSideCLength1 - (xloc + kSideCWingDHalfLen);
8094 xloc = kSideCLength1 + delta + kSideCWingEHalfLen;
8095 yloc = (xloc - kSideCLength1)*TMath::Tan(kSideCFoldAngle) +
8096 kSideCHeight2*TMath::Cos(kSideCFoldAngle) - kSideCHalfThick;
8097 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8098 alpharot = kSideCFoldAngle*TMath::RadToDeg();
8099 cableTrayC->AddNode(traySideCLateralWingE,1,
8100 new TGeoCombiTrans(xloc, yloc, zloc,
8101 new TGeoRotation("",alpharot,0,0) ) );
8102 cableTrayC->AddNode(traySideCLateralWingE,2,
8103 new TGeoCombiTrans(xloc, yloc,-zloc,
8104 new TGeoRotation("",alpharot,0,0) ) );
8105
8106 xloc = kSideCLength1 - kPlateHalfLen;
8107 yloc = -kPlateThick -0.0025; // Avoid small overlap
8108 cableTrayC->AddNode(traySideCLowerPlate,1,
8109 new TGeoTranslation(xloc, yloc, 0.) );
8110
8111 xloc = kSideCLength1 - kPlateHalfLen;
8112 yloc = -kPlateThick;
8113 zloc = kSideCHalfWide + 2*kSideCHalfThick + kPlateThick/2;
8114 cableTrayC->AddNode(traySideCLateralPlate,1,
8115 new TGeoTranslation(xloc, yloc, zloc) );
8116 cableTrayC->AddNode(traySideCLateralPlate,2,
8117 new TGeoTranslation(xloc, yloc,-zloc) );
8118
8119 for (Int_t jc = 0; jc <kNumBarCool; jc++) {
8120 xloc = kXShiftBarCool[jc];
8121 yloc = kYShiftBarCool[jc];
8122 cableTrayC->AddNode(coolingTubeBar,jc+1,
8123 new TGeoTranslation(xloc, yloc, 0.) );
8124 }
8125
8126 cableTrayC->AddNode(traySideCCoverFace,1,0);
8127
8128
8129 // Finally return what we made up
8130
8131 return cableTrayC;
8132}
8133