1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 //*************************************************************************
19 // SSD geometry, based on ROOT geometrical modeler
21 // Enrico Cattaruzza ecattar@ts.infn.it
22 //*************************************************************************
24 #include "TGeoVolume.h"
25 #include "TGeoMatrix.h"
26 #include <TGeoManager.h>
30 #include "TGeoMatrix.h"
31 #include "TGeoCompositeShape.h"
32 #include "TGeoBoolNode.h"
36 #include "TGeoTorus.h"
39 #include "TRotation.h"
40 #include "AliITSv11GeometrySSD.h"
42 /////////////////////////////////////////////////////////////////////////////////
43 // Names of the Sensitive Volumes of Layer 5 and Layer 6
44 /////////////////////////////////////////////////////////////////////////////////
45 const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName5 = "ITSssdSensitivL5";
46 const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName6 = "ITSssdSensitivL6";
47 /////////////////////////////////////////////////////////////////////////////////
48 //Parameters for SSD Geometry
49 /////////////////////////////////////////////////////////////////////////////////
50 // Variable for Vertical Disalignement of Modules
51 /////////////////////////////////////////////////////////////////////////////////
52 const Double_t AliITSv11GeometrySSD::fgkSSDTolerance = 0.0001*fgkmm;
53 const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
54 const Double_t AliITSv11GeometrySSD::fgkSSDModuleSideDisalignment = 0.2*fgkmm;
56 const Double_t AliITSv11GeometrySSD::fgkSSDLadderVerticalDisalignment = 0.520*fgkmm;
57 /////////////////////////////////////////////////////////////////////////////////
58 // Layer5 (lengths are in mm and angles in degrees)
59 /////////////////////////////////////////////////////////////////////////////////
60 const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
61 const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
62 const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
63 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
64 const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
65 const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
66 /////////////////////////////////////////////////////////////////////////////////
67 // Layer6 (lengths are in mm and angles in degrees)
68 /////////////////////////////////////////////////////////////////////////////////
69 const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
70 const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
71 const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
72 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
73 const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
74 const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
75 /////////////////////////////////////////////////////////////////////////////////
76 // SSD Chips and Hybrid (lengths are in mm and angles in degrees)
77 /////////////////////////////////////////////////////////////////////////////////
78 const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
79 const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
80 const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
81 const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
82 const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
83 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
84 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
85 const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
86 /////////////////////////////////////////////////////////////////////////////////
87 // Stiffener (lengths are in mm and angles in degrees)
88 /////////////////////////////////////////////////////////////////////////////////
89 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
90 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
91 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.295*fgkmm;
92 const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
93 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603CapLength = 0.900*fgkmm; // Includes solder
94 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
95 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
96 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
97 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812CapLength = 0.215*fgkmm;
98 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
99 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
100 const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 1.400*fgkmm;
101 const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
102 const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
103 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] = {44.32*fgkmm, 0.33*fgkmm};
104 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
105 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
106 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
107 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight = 0.25*fgkSSDStiffenerHeight;
108 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
109 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
110 const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSnHeight = 0.15*fgkmm;
111 /////////////////////////////////////////////////////////////////////////////////
112 // Cooling Block (lengths are in mm and angles in degrees)
113 /////////////////////////////////////////////////////////////////////////////////
114 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
115 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
116 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
117 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
118 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
119 {1.025*fgkmm, 0.120*fgkmm}; // Added 50 micron tolerance for thicker wall cooling pipe (March 2010)
120 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
121 {1.900*fgkmm, 0.400*fgkmm};
122 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
124 const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
126 /////////////////////////////////////////////////////////////////////////////////
127 // SSD Sensor (lengths are in mm and angles in degrees)
128 /////////////////////////////////////////////////////////////////////////////////
129 const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
130 "SSDSensorSensitiveVol";
131 const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
132 const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
133 const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
134 const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
135 fgkSSDSensorLength-39.1*fgkmm;
136 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
137 const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
138 /////////////////////////////////////////////////////////////////////////////////
139 // Flex (lengths are in mm and angles in degrees)
140 /////////////////////////////////////////////////////////////////////////////////
141 const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
142 const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
143 {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
144 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
145 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
146 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
147 - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
148 const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
149 { 9.340*fgkmm, 5.380*fgkmm};
150 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
151 { 0.030*fgkmm, 0.020*fgkmm};
152 const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
153 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
154 const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
155 const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
156 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
157 const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
158 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
159 /////////////////////////////////////////////////////////////////////////////////
160 // SSD Ladder Cable (lengths are in mm and angles in degrees)
161 /////////////////////////////////////////////////////////////////////////////////
162 const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
163 const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableHeight[2] = { 0.030*fgkmm*17.5/23.5, 1.25 * 0.030*fgkmm}; // Al covers ~ 17.5/23.5 of surface, Kapton includes glue+foam
164 /////////////////////////////////////////////////////////////////////////////////
165 // SSD Module (lengths are in mm and angles in degrees)
166 /////////////////////////////////////////////////////////////////////////////////
167 const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
168 { 1.000*fgkmm, 3.900*fgkmm};
169 const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
171 const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
173 /////////////////////////////////////////////////////////////////////////////////
174 // Sensor Support (lengths are in mm and angles in degrees)
175 /////////////////////////////////////////////////////////////////////////////////
176 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
178 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
180 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
181 { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment,
182 5.220*fgkmm-fgkSSDModuleVerticalDisalignment};
183 //const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
184 // { 4.520*fgkmm, 5.130*fgkmm};
185 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
186 { 0.450*fgkmm, 0.450*fgkmm};
187 const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
188 = 0.5 * (fgkSSDModuleSensorSupportDistance
189 + fgkSSDSensorSideSupportThickness[0])
190 - fgkSSDSensorSideSupportLength;
191 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
193 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
195 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
196 = {fgkSSDSensorSideSupportHeight[0]
197 + fgkSSDSensorSideSupportThickness[0],
198 fgkSSDSensorSideSupportHeight[1]
199 + fgkSSDSensorSideSupportThickness[1]};
200 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
201 = {fgkSSDSensorSideSupportThickness[0],
202 fgkSSDSensorSideSupportThickness[1]};
203 const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
205 /////////////////////////////////////////////////////////////////////////////////
206 // Chip Cables (lengths are in mm and angles in degrees)
207 /////////////////////////////////////////////////////////////////////////////////
208 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
209 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
210 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
211 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
212 - (fgkSSDSensorSideSupportHeight[1]
213 - fgkSSDSensorSideSupportHeight[0])
214 - fgkSSDModuleVerticalDisalignment
215 - fgkSSDCoolingBlockHoleCenter
216 - fgkSSDStiffenerHeight
217 - fgkSSDChipHeight-fgkSSDSensorHeight,
218 fgkSSDModuleCoolingBlockToSensor
219 - fgkSSDModuleVerticalDisalignment
220 - fgkSSDCoolingBlockHoleCenter
221 - fgkSSDStiffenerHeight
222 - fgkSSDChipHeight-fgkSSDSensorHeight};
223 const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
224 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
225 /////////////////////////////////////////////////////////////////////////////////
226 // Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
227 /////////////////////////////////////////////////////////////////////////////////
228 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
230 //const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
232 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
233 fgkSSDSensorLength-fgkSSDSensorOverlap;
234 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
235 { 0.86*fgkmm, 0.30*fgkmm};
236 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
238 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
240 /////////////////////////////////////////////////////////////////////////////////
241 //Carbon Fiber Parameters (lengths are in mm and angles in degrees)
242 /////////////////////////////////////////////////////////////////////////////////
243 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
244 = fgkSSDModuleSensorSupportDistance
245 - 2. * fgkCarbonFiberJunctionToSensorSupport;
246 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
247 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
248 { 0.751*fgkmm, 0.482*fgkmm};
249 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
251 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
252 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
253 = fgkCarbonFiberTriangleLength
254 - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
255 / TMath::Cos(fgkCarbonFiberTriangleAngle
256 * TMath::DegToRad());
257 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
258 = 0.5*(fgkCarbonFiberJunctionWidth
259 - fgkCarbonFiberSupportWidth)
260 - fgkCarbonFiberSupportTopEdgeDist[0]
261 - fgkCarbonFiberSupportWidth;
262 /////////////////////////////////////////////////////////////////////////////////
263 // Carbon Fiber Lower Support Parameters (lengths are in mm)
264 /////////////////////////////////////////////////////////////////////////////////
265 const Double_t AliITSv11GeometrySSD::fgkLowerSupportToSensorZ = 11.575*fgkmm;
266 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
268 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
270 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
272 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
273 = 0.5*fgkCarbonFiberSupportWidth;
274 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
275 = fgkCarbonFiberJunctionWidth
276 - 2. * (fgkCarbonFiberLowerSupportWidth
277 + fgkCarbonFiberLowerSupportVolumeSeparation);
278 const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
279 = {fgkCarbonFiberLowerSupportWidth
280 + fgkCarbonFiberLowerSupportVolumeSeparation,
281 fgkCarbonFiberLowerSupportWidth
282 + fgkCarbonFiberLowerSupportVolumeSeparation
283 + fgkCarbonFiberLowerSupportTransverseWidth};
284 /////////////////////////////////////////////////////////////////////////////////
285 // End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
286 /////////////////////////////////////////////////////////////////////////////////
287 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
288 {0.5 * (fgkSSDLay5LadderLength
289 - fgkSSDLay5SensorsNumber
290 * fgkCarbonFiberJunctionWidth
291 - fgkCarbonFiberLowerSupportWidth),
292 0.5 * (fgkSSDLay5LadderLength
293 - fgkSSDLay5SensorsNumber
294 * fgkCarbonFiberJunctionWidth
295 + fgkCarbonFiberLowerSupportWidth)};
296 const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
297 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
298 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
299 const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
300 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
301 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
302 const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
303 {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
304 /////////////////////////////////////////////////////////////////////////////////
305 // Cooling Tube Support (lengths are in mm and angles in degrees)
306 /////////////////////////////////////////////////////////////////////////////////
307 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
308 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
309 = fgkSSDCoolingBlockHoleRadius[0];
310 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
311 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
312 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
313 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
314 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
315 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
317 /////////////////////////////////////////////////////////////////////////////////
318 // Cooling Tube (lengths are in mm and angles in degrees)
319 /////////////////////////////////////////////////////////////////////////////////
320 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
321 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 1.915*fgkmm/2; // Nominal + 50 micron tolerance; real pipes are closer to 450 micron wall thickness
322 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
323 fgkCarbonFiberJunctionWidth;
324 const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
325 fgkSSDModuleSensorSupportDistance
326 + fgkSSDCoolingBlockLength;
327 const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
328 /////////////////////////////////////////////////////////////////////////////////
329 // SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
330 /////////////////////////////////////////////////////////////////////////////////
331 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
332 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
333 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
334 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
335 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
337 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
339 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
340 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
341 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
343 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
344 { 56.0*fgkmm, 12.0*fgkmm};
345 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
346 { 5.0*fgkmm, 2.9*fgkmm};
347 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
349 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
351 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeight =
353 const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
354 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
355 /////////////////////////////////////////////////////////////////////////////////
356 // SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
357 /////////////////////////////////////////////////////////////////////////////////
358 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
359 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
360 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
361 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
362 const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
363 /////////////////////////////////////////////////////////////////////////////////
364 // SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
365 /////////////////////////////////////////////////////////////////////////////////
366 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
367 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
368 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
369 - fgkSSDMountingBlockHeight[1]
370 + 0.5*fgkCoolingTubeSupportHeight
371 + fgkSSDModuleCoolingBlockToSensor
372 - fgkMountingBlockSupportDownHeight,
374 - fgkSSDMountingBlockHeight[1]
375 + 0.5*fgkCoolingTubeSupportHeight
376 + fgkSSDModuleCoolingBlockToSensor
377 - fgkMountingBlockSupportDownHeight};
378 const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
379 - fgkSSDMountingBlockHeight[1]
380 + 0.5*fgkCoolingTubeSupportHeight
381 + fgkSSDModuleCoolingBlockToSensor
382 - fgkMountingBlockSupportRadius[0],
384 - fgkSSDMountingBlockHeight[1]
385 + 0.5*fgkCoolingTubeSupportHeight
386 + fgkSSDModuleCoolingBlockToSensor
387 - fgkMountingBlockSupportRadius[1]};
388 const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeight = 10.0*fgkmm; // To be verified
389 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
390 const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
391 /////////////////////////////////////////////////////////////////////////////////
392 // SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
393 /////////////////////////////////////////////////////////////////////////////////
394 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
395 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
396 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
397 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
398 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
399 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
400 {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
401 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
402 {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
403 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
404 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
405 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
406 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
407 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
408 const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
409 /////////////////////////////////////////////////////////////////////////////////
410 // SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
411 /////////////////////////////////////////////////////////////////////////////////
412 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
413 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
414 const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
415 /////////////////////////////////////////////////////////////////////////////////
416 // SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
417 /////////////////////////////////////////////////////////////////////////////////
418 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
419 {10.5*fgkmm,9.25*fgkmm};
420 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
421 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
422 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
423 {182.3,177.9,84.4,70.0,35.0};
424 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
425 {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
426 const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
427 /////////////////////////////////////////////////////////////////////////////////
428 // SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
429 /////////////////////////////////////////////////////////////////////////////////
430 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
431 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
432 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
433 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
434 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
435 const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
436 /////////////////////////////////////////////////////////////////////////////////
437 // SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
438 /////////////////////////////////////////////////////////////////////////////////
439 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
440 {62.0*fgkmm,21.87*fgkmm};
441 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
442 {47.0*fgkmm,0.35*fgkmm};
443 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
445 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
446 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
447 {43.5*fgkmm, 0.70*fgkmm};
448 const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
450 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
452 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
453 {4.80*fgkmm,1.1*fgkmm};
454 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
455 {3.3*fgkmm,1.10*fgkmm};
456 const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
458 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
459 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
460 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
461 {1.9*fgkmm,0.15*fgkmm};
462 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
464 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
466 const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
468 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
470 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
472 const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
473 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
474 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
475 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
476 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
477 {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
478 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
480 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
482 const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
484 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
485 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
486 const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
487 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
488 const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
489 /////////////////////////////////////////////////////////////////////////////////
490 // SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
491 /////////////////////////////////////////////////////////////////////////////////
492 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
493 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
494 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {375.0*fgkmm,435.0*fgkmm};
495 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
496 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
497 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 624.9*fgkmm;
498 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
499 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
500 const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
501 /////////////////////////////////////////////////////////////////////////////////
502 // SSD Cone Parameters (lengths are in mm and angles in degrees)
503 /////////////////////////////////////////////////////////////////////////////////
504 const Double_t AliITSv11GeometrySSD::fgkSSDLowerPConeRadius = 296.5*fgkmm;
505 const Double_t AliITSv11GeometrySSD::fgkSSDPConeAngle = 39.0;
506 const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {168.0*fgkmm,153.0*fgkmm};
507 const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleRadius = 317.5*fgkmm;
508 const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleLength = 20.*fgkmm;
509 const Double_t AliITSv11GeometrySSD::fgkSSDConeMiddleRadius = 350.*fgkmm;
510 const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleLength = 30.*fgkmm;
511 const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleWidth = 40.*fgkmm;
512 const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpRadius = 400.*fgkmm;
513 const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 459.*fgkmm;
514 const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMiddleRadius = 472.5*fgkmm;
515 const Double_t AliITSv11GeometrySSD::fgkSSDPConeDownRadius = 282.0*fgkmm;
516 const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidAngle = 42.0;
517 const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidBasis = 200.0*fgkmm;
518 const Double_t AliITSv11GeometrySSD::fgkSSDPConeExternalRadius = 492.5*fgkmm;
519 const Double_t AliITSv11GeometrySSD::fgkSSDPConeRadiusWidth = 16.75*fgkmm;
520 const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 168.0*fgkmm;
521 const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportLength = 1020.*fgkmm;
522 const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm;
523 const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm;
524 const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportLength = 60.0*fgkmm;
525 const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportWidth = 2.5*fgkSSDCentralSupportWidth;
527 /////////////////////////////////////////////////////////////////////////////////
528 ClassImp(AliITSv11GeometrySSD)
529 /////////////////////////////////////////////////////////////////////////////////
530 AliITSv11GeometrySSD::AliITSv11GeometrySSD():
533 fSSDChipGlueMedium(),
534 fSSDStiffenerMedium(),
535 fSSDStiffenerConnectorMedium(),
536 fSSDStiffener0603CapacitorMedium(),
537 fSSDStiffener1812CapacitorMedium(),
538 fSSDStiffenerCapacitorCapMedium(),
539 fSSDStiffenerHybridWireMedium(),
540 fSSDKaptonFlexMedium(),
541 fSSDAlTraceFlexMedium(),
542 fSSDAlTraceLadderCableMedium(),
543 fSSDKaptonLadderCableMedium(),
544 fSSDKaptonChipCableMedium(),
545 fSSDAlTraceChipCableMedium(),
546 fSSDAlCoolBlockMedium(),
548 fSSDSensorSupportMedium(),
549 fSSDCarbonFiberMedium(),
550 fSSDTubeHolderMedium(),
551 fSSDCoolingTubeWater(),
552 fSSDCoolingTubePhynox(),
554 fSSDMountingBlockMedium(),
559 fCreateMaterials(kFALSE),
560 fTransformationMatrices(kFALSE),
561 fBasicObjects(kFALSE),
562 fcarbonfiberjunction(),
563 fcoolingtubesupport(),
565 fssdcoolingblocksystem(),
566 fcoolingblocksystematrix(),
570 fendladdercoolingtubesupportmatrix(),
571 fendladdermountingblock(),
572 fendladdermountingblockclip(),
578 fLay5LadderSupportRing(),
579 fLay6LadderSupportRing(),
580 fgkEndCapSupportSystem(),
582 fColorCarbonFiber(4),
595 ////////////////////////
596 // Standard constructor
597 ////////////////////////
598 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++){
599 fendladdermountingblockcombitrans[i] = NULL;
601 for (Int_t i=0; i < fgkcarbonfibersupportnumber; i++) {
602 fcarbonfibersupport[i] = 0;
603 fcarbonfibersupportmatrix[i] = 0;
605 for (Int_t i=0; i < fgkcarbonfiberjunctionumber; i++) {
606 fcarbonfiberjunctionmatrix[i] = 0;
608 for (Int_t i=0; i < fgkcarbonfiberlowersupportnumber; i++) {
609 fcarbonfiberlowersupport[i] = 0;
610 fcarbonfiberlowersupportrans[0] = 0;
612 for (Int_t i=0; i < fgkvolumekind; i++) {
613 fssdsensorsupport[i] = 0;
615 for (Int_t i=0; i < fgkssdsensorsupportnumber; i++) {
616 fssdsensorsupportmatrix[i] = 0;
618 for (Int_t i=0; i < fgkcoolingtubesupportnumber; i++) {
619 fcoolingtubesupportmatrix[i] = 0;
621 for (Int_t i=0; i < fgkhybridcompnumber; i++) {
622 fssdhybridcomponent[i] = 0;
624 for (Int_t i=0; i < fgkcoolingblocknumber; i++) {
625 fcoolingblockmatrix[i] = 0;
627 for (Int_t i=0; i < fgkflexnumber; i++) {
628 fstiffenerflexmatrix[i] = 0;
629 fendflexmatrix[i] = 0;
631 for (Int_t i=0; i < fgkendladdercoolingtubenumber; i++) {
632 fendladdercoolingtube[i] = 0;
633 for (Int_t j = 0; j < 2; j++)
634 fendladdercoolingtubematrix[i][j] = 0;
636 for (Int_t i=0; i < fgkendlabbercarbonfiberjunctionumber; i++) {
637 fendladdercarbonfiberjunction[i] = 0;
639 for (Int_t i=0; i < fgkendladdercarbonfiberjunctionmatrixnumber; i++) {
640 fendladdercarbonfiberjunctionmatrix[i] = 0;
642 for (Int_t i=0; i < fgkendladdercarbonfibermatrixnumber; i++) {
643 fendladdercarbonfibermatrix[i] = 0;
645 for (Int_t i=0; i < fgkendladdermountingblocknumber; i++) {
646 fendladdermountingblockclipmatrix[i] = 0;
648 for (Int_t i = 0; i < fgkendladderlowersuppnumber+1; i++) {
649 fendladderlowersupptrans[i] = 0;
651 for (Int_t i = 0; i < fgkladdercablesnumber; i++) {
652 fladdercablematrix[i] = 0;
654 for (Int_t i = 0; i < fgkladdersegmentnumber; i++) {
655 fladdersegment[i] = 0;
657 for (Int_t i = 0; i < fgkladdernumber; i++) {
659 fladdermatrix[i] = 0;
660 fssdsensormatrix[i] = 0;
663 for (Int_t i = 0; i < 2; i++) {
664 fLay5LadderSupport[i] = 0;
665 fLay6LadderSupport[i] = 0;
666 fcoolingtubematrix[i] = NULL;
667 fendladdersegment[i] = NULL;
668 fendladdersegmentmatrix[i] = NULL;
672 ///////////////////////////////////////////////////////////////////////////////
673 void AliITSv11GeometrySSD::CreateTransformationMatrices(){
674 ///////////////////////////////////////////////////////////////////////
675 // Method generating the trasformation matrix for the whole SSD Geometry
676 ///////////////////////////////////////////////////////////////////////
677 // Setting some variables for Carbon Fiber Supportmatrix creation
678 //////////////////////////////////////////////////////////////////////
679 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
680 * CosD(fgkCarbonFiberJunctionAngle[0]);
681 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
682 + fgkCarbonFiberSupportTopEdgeDist[0]
683 + fgkCarbonFiberSupportWidth);
684 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
685 * TanD(fgkCarbonFiberJunctionAngle[0]);
686 TGeoRotation* carbonfiberot[3];
687 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
688 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
689 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
690 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
691 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
692 * CosD(fgkCarbonFiberTriangleAngle),0.,
693 - fgkCarbonFiberTriangleLength
694 * SinD(fgkCarbonFiberTriangleAngle)};
695 ///////////////////////////////////////////
696 //Setting Local Translations and Rotations:
697 ///////////////////////////////////////////
698 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
699 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
700 0.5*carbonfibersupportheight,NULL);
701 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
702 2.*symmetryplaneposition+transvector[1],
703 transvector[2], carbonfiberot[2]);
704 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
705 /////////////////////////////////////////////////////////////
706 // Carbon Fiber Support Transformations
707 /////////////////////////////////////////////////////////////
708 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
709 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
710 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
711 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
712 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
714 /////////////////////////////////////////////////////////////
715 // Carbon Fiber Junction Transformation
716 /////////////////////////////////////////////////////////////
717 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
718 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
719 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
720 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
721 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
722 localcarbonfiberjunctionmatrix[i] =
723 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
724 localcarbonfiberjunctionrot[i] =
725 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
726 localcarbonfiberjunctiontrans[i] =
727 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
729 ///////////////////////
730 // Setting Translations
731 ///////////////////////
732 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
733 localcarbonfiberjunctiontrans[1][0] =
734 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
735 localcarbonfiberjunctiontrans[2][0] =
736 new TGeoTranslation(fgkCarbonFiberTriangleLength
737 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
738 fgkCarbonFiberTriangleLength
739 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
740 localcarbonfiberjunctiontrans[0][1] =
741 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
742 localcarbonfiberjunctiontrans[1][1] =
743 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
744 localcarbonfiberjunctiontrans[2][1] =
745 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
749 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
750 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
751 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
752 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
753 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
754 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
755 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
756 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
757 ////////////////////////////////////////
758 // Setting Carbon Fiber Junction matrix
759 ////////////////////////////////////////
760 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
761 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
762 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
763 localcarbonfiberjunctionmatrix[i][j] =
764 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
765 *localcarbonfiberjunctionrot[i][j]);
766 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
769 /////////////////////////////////////////////////////////////
770 // Carbon Fiber Lower Support Transformations
771 /////////////////////////////////////////////////////////////
772 TGeoTranslation* localcarbonfiberlowersupportrans[2];
773 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
774 fgkCarbonFiberLowerSupportVolumePosition[1]
775 + fgkCarbonFiberLowerSupportVolumePosition[0],
777 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
778 fgkCarbonFiberJunctionWidth
779 - fgkCarbonFiberLowerSupportWidth
780 - fgkCarbonFiberLowerSupportVolumePosition[0]
781 - fgkCarbonFiberLowerSupportVolumePosition[1],
782 - 0.5*fgkCarbonFiberLowerSupportHeight);
783 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
784 fcarbonfiberlowersupportrans[0] =
785 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
786 fcarbonfiberlowersupportrans[1] =
787 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
788 /////////////////////////////////////////////////////////////
789 // SSD Sensor Support Transformations
790 /////////////////////////////////////////////////////////////
791 const Int_t kssdsensorsupportmatrixnumber = 3;
792 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
793 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
794 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
795 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
796 localssdsensorsupportmatrix[i] =
797 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
798 localssdsensorsupportrot[i] =
799 new TGeoRotation*[kssdsensorsupportmatrixnumber];
800 localssdsensorsupportrans[i] =
801 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
803 ///////////////////////
804 // Setting Translations
805 ///////////////////////
806 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
807 0.5*fgkSSDSensorSideSupportWidth,
809 localssdsensorsupportrans[1][0] =
810 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
811 localssdsensorsupportrans[2][0] =
812 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
813 localssdsensorsupportrans[0][1] =
814 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
815 0.5*fgkSSDSensorSideSupportThickness[0],
817 localssdsensorsupportrans[1][1] =
818 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
819 - 0.5*fgkSSDSensorSideSupportThickness[0]
820 - fgkSSDModuleSensorSupportDistance,
822 localssdsensorsupportrans[2][1] =
823 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
824 - fgkSSDSensorCenterSupportPosition,
825 0.5*fgkSSDSensorCenterSupportWidth
826 - 0.5*fgkSSDModuleSensorSupportDistance,
827 fgkSSDSensorCenterSupportThickness[0]);
828 localssdsensorsupportrans[0][2] =
829 new TGeoTranslation(fgkCarbonFiberTriangleLength
830 + fgkCarbonFiberJunctionToSensorSupport,
831 fgkCarbonFiberJunctionWidth
832 - 0.5*(fgkCarbonFiberLowerSupportWidth
833 + fgkSSDSensorCenterSupportLength
834 - fgkSSDSensorCenterSupportThickness[0])
835 - fgkSSDSensorCenterSupportPosition,
837 localssdsensorsupportrans[1][2] =
838 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
839 localssdsensorsupportrans[2][2] =
840 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
844 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
845 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
846 localssdsensorsupportrot[i][j] = new TGeoRotation();
847 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
848 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
849 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
851 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
852 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
853 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
854 ////////////////////////////////////////
855 // SSD Sensor Support matrix
856 ////////////////////////////////////////
857 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
858 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
859 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
860 localssdsensorsupportmatrix[i][j] =
861 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
862 *localssdsensorsupportrot[i][j]);
863 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
866 /////////////////////////////////////////////////////////////
867 // SSD Cooling Tube Support Transformations
868 /////////////////////////////////////////////////////////////
869 const Int_t kcoolingtubesupportmatrixnumber = 2;
870 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
871 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
872 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
873 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
874 /fgkCoolingTubeSupportRmax);
875 localcoolingtubesupportrans[0] =
876 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
877 + 2.*(fgkCoolingTubeSupportLength
878 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
879 + fgkCarbonFiberTriangleLength
880 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
881 localcoolingtubesupportrans[1] =
882 new TGeoTranslation(fgkCarbonFiberJunctionLength
883 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
884 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
885 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
886 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
887 - 0.5*(fgkCarbonFiberLowerSupportWidth
888 + fgkSSDSensorCenterSupportLength
889 - fgkSSDSensorCenterSupportThickness[0])
890 + 0.5*fgkSSDSensorLength,
891 - 0.5*fgkCoolingTubeSupportHeight);
892 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
893 localcoolingtubesupportrot[i] = new TGeoRotation();
894 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
895 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
896 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
897 localcoolingtubesupportmatrix[i] =
898 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
899 *localcoolingtubesupportrot[i]);
900 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
901 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
902 (*localcoolingtubesupportmatrix[0]));
903 /////////////////////////////////////////////////////////////
904 // End Ladder SSD Cooling Tube Support Transformations
905 /////////////////////////////////////////////////////////////
906 TGeoTranslation** localendladdercooltubetrans[2];
907 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
908 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
909 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
910 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
911 - (fgkCoolingTubeSupportLength
912 - fgkCoolingTubeSupportRmax),
913 fgkEndLadderMountingBlockPosition[0]
914 - fgkendladdercoolingsupportdistance[0]
915 + 0.5*fgkCoolingTubeSupportWidth,
916 - 0.5*fgkCoolingTubeSupportHeight);
917 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
918 - (fgkCoolingTubeSupportLength
919 - fgkCoolingTubeSupportRmax),
920 fgkEndLadderMountingBlockPosition[0]
921 + fgkendladdercoolingsupportdistance[1]
922 + 0.5*fgkCoolingTubeSupportWidth,
923 - 0.5*fgkCoolingTubeSupportHeight);
924 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
925 - fgkCoolingTubeSupportRmax)
926 + fgkCarbonFiberTriangleLength
927 - 2.0*fgkCarbonFiberJunctionLength,
930 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
931 fgkendladdercoolingsupportdistance[0]
932 + fgkendladdercoolingsupportdistance[1],
934 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
935 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
936 + fgkCarbonFiberJunctionLength
937 - fgkCoolingTubeSupportLength,
938 fgkEndLadderCarbonFiberLowerJunctionLength[1]
939 - 0.5*fgkCoolingTubeSupportWidth
940 -fgkendladdercoolingsupportdistance[2],
941 - 0.5*fgkCoolingTubeSupportHeight);
942 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
943 + fgkCoolingTubeSupportLength
944 - fgkCoolingTubeSupportRmax
945 - fgkCarbonFiberJunctionLength,
946 fgkEndLadderCarbonFiberLowerJunctionLength[1]
947 - 0.5*fgkCoolingTubeSupportWidth
948 - fgkendladdercoolingsupportdistance[2],
949 - 0.5*fgkCoolingTubeSupportHeight);
950 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
951 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
952 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
953 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
954 (*localcoolingtubesupportrot[1]));
955 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
956 (*localcoolingtubesupportrot[1]));
957 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
958 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
959 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
960 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
961 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
963 fendladdercoolingtubesupportmatrix[1][0] =
964 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
965 *(*localcoolingtubesupportrot[1]));
966 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
967 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
968 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
969 /////////////////////////////////////////////////////////////
970 // SSD Cooling Tube Transformations
971 /////////////////////////////////////////////////////////////
972 TGeoRotation* localcoolingtuberot = new TGeoRotation();
973 localcoolingtuberot->SetAngles(0.,90.,0.);
974 TGeoTranslation* localcoolingtubetrans[2];
975 TVector3* localcoolingtubevect[2];
977 localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
978 -fgkCarbonFiberTriangleLength),
979 fgkCarbonFiberJunctionWidth // Y-coord is local Z, from sensor translation
980 - fgkCarbonFiberLowerSupportWidth
981 - fgkLowerSupportToSensorZ ,
982 - 0.5*fgkCoolingTubeSupportHeight);
983 localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
984 localcoolingtubevect[0]->Y(),
985 localcoolingtubevect[0]->Z());
986 for(Int_t j=0; j<2; j++){
987 localcoolingtubetrans[j] =
988 new TGeoTranslation(localcoolingtubevect[j]->X(),
989 localcoolingtubevect[j]->Y(),
990 localcoolingtubevect[j]->Z());
991 fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j])
992 *(*localcoolingtuberot));
994 /////////////////////////////////////////////////////////////
995 // SSD End Ladder Cooling Tube Transformations
996 /////////////////////////////////////////////////////////////
997 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
998 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
999 TGeoTranslation** localendlladdercoolingtubetrans[2];
1000 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
1001 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
1002 for(Int_t i=0; i<2; i++)
1003 for(Int_t j=0; j<2; j++)
1004 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1006 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
1007 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1008 - fgkCoolingTubeSupportRmax)
1009 + fgkCarbonFiberJunctionLength,
1010 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
1011 - 0.5*fgkCoolingTubeSupportHeight);
1012 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1013 - fgkCoolingTubeSupportRmax)
1014 - fgkCarbonFiberJunctionLength
1015 + fgkCarbonFiberTriangleLength,
1016 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
1017 - 0.5*fgkCoolingTubeSupportHeight);
1019 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1020 - fgkCoolingTubeSupportRmax)
1021 + fgkCarbonFiberJunctionLength,
1022 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
1023 - 0.5*fgkCoolingTubeSupportHeight);
1024 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1025 - fgkCoolingTubeSupportRmax)
1026 - fgkCarbonFiberJunctionLength
1027 + fgkCarbonFiberTriangleLength,
1028 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
1029 - 0.5*fgkCoolingTubeSupportHeight);
1030 for(Int_t i=0; i<2; i++)
1031 for(Int_t j=0; j<2; j++){
1032 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1033 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1035 /////////////////////////////////////////////////////////////
1036 // SSD Hybrid Components Transformations
1037 /////////////////////////////////////////////////////////////
1038 const Int_t khybridmatrixnumber = 3;
1039 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1040 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1041 0.5*fgkSSDStiffenerWidth,
1042 0.5*fgkSSDStiffenerHeight);
1043 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1044 fgkSSDModuleStiffenerPosition[1],0.0);
1046 localhybridtrans[2] = new TGeoTranslation(
1047 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1048 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1049 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1050 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1051 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1052 - fgkSSDSensorCenterSupportThickness[0]),
1053 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1054 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
1055 - fgkSSDModuleVerticalDisalignment));
1056 fhybridmatrix = new TGeoHMatrix();
1057 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1058 /////////////////////////////////////////////////////////////
1059 // SSD Cooling Block Transformations
1060 /////////////////////////////////////////////////////////////
1061 TGeoTranslation localcoolingblocktrans (fcoolingtubematrix[0]->GetTranslation()[0]
1062 - 0.5*fgkSSDCoolingBlockLength,
1063 fhybridmatrix->GetTranslation()[1]-0.5*fgkSSDStiffenerWidth,
1064 fhybridmatrix->GetTranslation()[2]+0.5*fgkSSDStiffenerHeight+
1065 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1066 fcoolingblocksystematrix = new TGeoHMatrix(localcoolingblocktrans);
1067 /////////////////////////////////////////////////////////////
1068 // SSD Stiffener Flex Transformations
1069 /////////////////////////////////////////////////////////////
1070 const Int_t klocalflexmatrixnumber = 4;
1071 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1072 for(Int_t i=0; i<fgkflexnumber; i++)
1073 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1074 for(Int_t i=0; i<fgkflexnumber; i++)
1075 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1076 localflexmatrix[i][j] = new TGeoCombiTrans();
1077 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1078 - 2.*fgkSSDModuleStiffenerPosition[1]
1079 - fgkSSDStiffenerWidth;
1080 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1081 +0.5*fgkSSDStiffenerLength,
1082 0.5*fgkSSDStiffenerWidth,
1083 -0.5*fgkSSDStiffenerHeight
1084 -0.5*fgkSSDFlexHeight[0]);
1085 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1086 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1087 -0.5*fgkSSDStiffenerWidth,
1088 -0.5*fgkSSDStiffenerHeight
1089 -0.5*fgkSSDFlexHeight[0]);
1090 TGeoRotation* localflexrot = new TGeoRotation();
1091 localflexrot->SetAngles(180.,0.,0.);
1092 localflexmatrix[1][0]->SetRotation(localflexrot);
1093 for(Int_t i=0; i<fgkflexnumber; i++)
1094 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1095 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1096 for(Int_t i=0; i<fgkflexnumber; i++){
1097 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1098 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1099 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
1101 /////////////////////////////////////////////////////////////
1102 // SSD End Flex Transformations
1103 /////////////////////////////////////////////////////////////
1104 TGeoRotation* localendflexrot = new TGeoRotation();
1105 localendflexrot->SetAngles(0.0,90.0,0.0);
1106 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1107 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1108 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1109 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1110 * TMath::DegToRad()*ssdflexradiusmax
1111 - fgkSSDFlexLength[2]-TMath::Pi()
1112 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1113 - 0.1*fgkSSDFlexFullLength;
1114 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1115 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1116 + fgkSSDFlexLength[2];
1117 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1118 0.5*fgkSSDFlexWidth[0],
1119 2.*fgkSSDStiffenerHeight
1120 + 0.5*fgkSSDFlexHeight[0]);
1121 localendflexmatrix->SetRotation(localendflexrot);
1122 for(Int_t i=0; i<fgkflexnumber; i++)
1123 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1124 /////////////////////////////////////////////////////////////
1125 // End Ladder Carbon Fiber Junction
1126 /////////////////////////////////////////////////////////////
1127 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1128 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1129 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1130 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1131 localendladdercarbonfiberjunctionmatrix[i]
1132 = new TGeoCombiTrans*[fgkendladdercarbonfiberjunctionmatrixnumber];
1133 localendladdercarbonfiberjunctionrot[i]
1134 = new TGeoRotation*[fgkendladdercarbonfiberjunctionmatrixnumber];
1135 localendladdercarbonfiberjunctiontrans[i]
1136 = new TGeoTranslation*[fgkendladdercarbonfiberjunctionmatrixnumber];
1137 fendladdercarbonfiberjunctionmatrix[i]
1138 = new TGeoHMatrix*[fgkendladdercarbonfiberjunctionmatrixnumber];
1140 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1141 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
1142 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1143 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1145 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1146 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
1147 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1148 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1149 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1151 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1152 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1153 * SinD(fgkCarbonFiberTriangleAngle),
1154 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1155 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1157 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1158 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1159 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1160 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1161 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1162 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1163 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1164 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1165 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1166 localendladdercarbonfiberjunctionglobalmatrix[i] =
1167 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1168 *localendladdercarbonfiberjunctionglobalrot[i]);
1170 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1171 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
1172 localendladdercarbonfiberjunctionmatrix[i][j] =
1173 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1174 *localendladdercarbonfiberjunctionrot[i][j]);
1175 fendladdercarbonfiberjunctionmatrix[i][j] =
1176 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1177 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1179 /////////////////////////////////////////////////////////////
1180 // End Ladder Carbon Fiber Support
1181 /////////////////////////////////////////////////////////////
1182 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1183 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1184 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1185 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1186 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1187 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1189 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1190 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1191 fendladdercarbonfibermatrix[i][j] =
1192 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1193 *(*fcarbonfibersupportmatrix[j]));
1194 /////////////////////////////////////////////////////////////
1195 // End Ladder SSD Mounting Block
1196 /////////////////////////////////////////////////////////////
1197 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1198 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1199 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1200 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
1201 + fgkSSDMountingBlockLength[1])
1202 + 0.5*fgkCarbonFiberTriangleLength,
1203 fgkEndLadderMountingBlockPosition[i],
1204 - fgkSSDMountingBlockHeight[1]
1205 + 0.5*fgkSSDMountingBlockHeight[0]);
1206 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1207 endladdermountingblockrot->SetAngles(0.,90.,0.);
1208 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1209 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1210 /////////////////////////////////////////////////////////////
1211 // End Ladder SSD Mounting Block Clip Matrix
1212 /////////////////////////////////////////////////////////////
1213 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1214 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1216 TGeoRotation* localendladdercliprot = new TGeoRotation();
1217 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1218 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1219 - fgkSSDMountingBlockLength[1])
1220 + fgkSSDMountingBlockLength[0],0.,0.);
1221 localendladdercliprot->SetAngles(90.,180.,-90.);
1222 TGeoCombiTrans* localendladderclipcombitrans =
1223 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1224 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1225 for(Int_t j=0; j<2; j++){
1226 fendladdermountingblockclipmatrix[i][j] =
1227 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1228 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1230 /////////////////////////////////////////////////////////////
1231 // End Ladder Carbon Fiber Lower Support
1232 /////////////////////////////////////////////////////////////
1233 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1234 fendladderlowersupptrans[i] =
1235 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1236 + 0.5*fgkSSDMountingBlockWidth),
1237 - 0.5*fgkCarbonFiberLowerSupportHeight);
1238 fendladderlowersupptrans[0]->SetDz(-0.5*fgkCarbonFiberLowerSupportHeight-fgkSSDTolerance);
1239 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1240 fgkCarbonFiberLowerSupportVolumePosition[1]
1241 + fgkCarbonFiberLowerSupportVolumePosition[0],
1243 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1244 /////////////////////////////////////////////////////////////
1245 // Matrix for positioning Ladder into mother volume
1246 /////////////////////////////////////////////////////////////
1247 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1248 for(Int_t i=0; i<fgkladdernumber; i++)
1249 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1250 TGeoRotation* localladdermotherrot = new TGeoRotation();
1251 localladdermotherrot->SetAngles(0.,90.,0.);
1252 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1253 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1254 for(Int_t i=0; i<fgkladdernumber; i++){
1255 localladdermothertrans[i] = new TGeoTranslation(0.,
1256 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1257 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1258 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1259 * fgkCarbonFiberJunctionWidth,0.);
1260 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1261 *localladdermotherrot);
1262 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1263 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
1265 /////////////////////////////////////////////////////////////
1266 // Ladder Cables Matrices
1267 /////////////////////////////////////////////////////////////
1268 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
1269 + fgkSSDFlexHeight[1];
1270 Double_t ssdladdercabletransx[3];
1271 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1272 * SinD(2.*fgkSSDFlexAngle)
1273 * CosD(2.*fgkSSDFlexAngle);
1274 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1275 - ssdladdercabletransx[0]
1276 / SinD(2.*fgkSSDFlexAngle))
1277 * CosD(fgkSSDFlexAngle);
1278 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1279 * TMath::DegToRad()*ssdflexradiusmax
1280 - fgkSSDFlexLength[2]-TMath::Pi()
1281 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1282 - fgkSSDLadderCableWidth)
1283 * CosD(2.*fgkSSDFlexAngle);
1284 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
1285 * TanD(2.*fgkSSDFlexAngle),
1286 ssdladdercabletransx[1]
1287 * TanD(fgkSSDFlexAngle),
1288 ssdladdercabletransx[2]
1289 * TanD(2.*fgkSSDFlexAngle)};
1290 TGeoRotation* localladdercablerot[3];
1291 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1292 localladdercablerot[0]->SetAngles(90.,0.,0.);
1293 localladdercablerot[1]->SetAngles(90.,60.,-90.);
1294 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1295 * (*localladdercablerot[0]));
1296 //TGeoRotation* localladdercablerot = new TGeoRotation();
1297 //localladdercablerot->SetAngles(90.,0.,0.);
1298 ////////////////////////////////////////////
1299 // LocalLadderCableCombiTransMatrix
1300 ////////////////////////////////////////////
1301 const Int_t klocalladdersidecablesnumber = 2;
1302 const Int_t klocalladdercombitransnumber = 5;
1303 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1304 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1305 localladdercablecombitransmatrix[i] =
1306 new TGeoCombiTrans*[klocalladdercombitransnumber];
1307 ///////////////////////////////////////////
1308 // Left Side Ladder Cables Transformations
1309 ///////////////////////////////////////////
1310 localladdercablecombitransmatrix[0][0] =
1311 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1313 localladdercablecombitransmatrix[0][1] =
1314 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1315 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1316 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1317 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1318 - 0.5*(fgkCarbonFiberLowerSupportWidth
1319 + fgkSSDSensorCenterSupportLength
1320 - fgkSSDSensorCenterSupportThickness[0]),
1321 - (fgkSSDModuleCoolingBlockToSensor
1322 + 0.5*fgkCoolingTubeSupportHeight
1323 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1324 - fgkSSDChipHeight),NULL);
1325 localladdercablecombitransmatrix[0][2] =
1326 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1327 fgkSSDModuleStiffenerPosition[1],0.,0);
1328 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1329 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1330 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1331 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1332 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1333 new TGeoRotation("",180.,0.,0.));
1334 localladdercablecombitransmatrix[0][4] =
1335 new TGeoCombiTrans(-ssdladdercabletransx[0]
1336 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
1337 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1339 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1340 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
1341 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1342 + ssdladdercabletransz[2],localladdercablerot[2]);
1343 ///////////////////////////////////////////
1344 // Rigth Side Ladder Cables Transformations
1345 ///////////////////////////////////////////
1346 TGeoCombiTrans* localladdercablessdmodulematrix =
1347 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1348 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1349 fgkSSDStiffenerWidth,
1350 - 0.5*fgkSSDFlexHeight[0],NULL);
1351 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1352 localladdercablecombitransmatrix[1][i] =
1353 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1354 new TGeoCombiTrans(*localladdercablessdmodulematrix));
1355 ///////////////////////////////////////////
1356 // Setting LadderCableHMatrix
1357 ///////////////////////////////////////////
1358 Int_t beamaxistrans[2][3];
1359 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1360 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1361 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1362 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1363 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1364 beamaxistrans[1][2] = beamaxistrans[1][0];
1365 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1366 TGeoRotation* laddercablerot = new TGeoRotation();
1367 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1368 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1369 Double_t* laddercabletransvector;
1370 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1371 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1372 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1374 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1375 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1376 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1377 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1378 localladdercablehmatrix[i][j]->MultiplyLeft(
1379 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1381 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1382 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1383 laddercabletrans->SetTranslation(laddercabletransvector[0],
1384 laddercabletransvector[1]
1385 + (j==0 ? beamaxistrans[i][0] : 0.)
1386 * fgkCarbonFiberJunctionWidth,
1387 laddercabletransvector[2]);
1388 laddercablecombitrans->SetRotation(*laddercablerot);
1389 laddercablecombitrans->SetTranslation(*laddercabletrans);
1390 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1392 fladdercablematrix[i][2] =
1393 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1394 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1395 fladdercablematrix[i][3] =
1396 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1397 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1399 for(Int_t i=0; i<fgkladdercablesnumber; i++)
1400 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1401 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1403 ///////////////////////////////////////////
1404 // Setting Ladder HMatrix
1405 ///////////////////////////////////////////
1406 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1407 fgkSSDLay6SensorsNumber};
1408 for(Int_t i=0; i<fgkladdernumber; i++){
1409 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1410 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1411 fladdermatrix[i][j] = new TGeoHMatrix();
1412 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1413 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1414 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1417 ///////////////////////////////////////////
1418 // Setting SSD Sensor Matrix
1419 ///////////////////////////////////////////
1420 TGeoCombiTrans* localssdsensorcombitrans[2];
1421 TGeoRotation* localssdsensorrot = new TGeoRotation();
1422 localssdsensorrot->SetAngles(0.,90.,0.);
1423 TGeoTranslation* localssdsensortrans[2];
1424 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1425 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1426 fgkCarbonFiberJunctionWidth
1427 - fgkCarbonFiberLowerSupportWidth
1428 - fgkLowerSupportToSensorZ,
1429 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1430 - fgkSSDModuleCoolingBlockToSensor
1431 + (fgkSSDSensorSideSupportHeight[1]
1432 - fgkSSDSensorSideSupportHeight[0]));
1433 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1434 fgkCarbonFiberJunctionWidth
1435 - fgkCarbonFiberLowerSupportWidth
1436 - fgkLowerSupportToSensorZ,
1437 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1438 -fgkSSDModuleCoolingBlockToSensor);
1440 for(Int_t i=0; i<2; i++)
1441 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1442 *localssdsensorrot);
1443 for(Int_t i=0; i<fgkladdernumber; i++){
1444 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1445 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1447 case 0: //Ladder of Layer5
1448 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1449 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1450 *localssdsensorcombitrans[1])));
1452 case 1: //Ladder of Layer6
1453 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1454 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1455 *localssdsensorcombitrans[0])));
1460 //////////////////////////
1461 // Setting SSD End Ladder
1462 //////////////////////////
1463 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1464 for(Int_t i=0; i<2; i++){
1465 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1466 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1467 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1468 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1469 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1470 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1471 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1472 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1474 /////////////////////////////////////////////////////
1475 // Setting the CombiTransformation to pass ITS center
1476 /////////////////////////////////////////////////////
1477 Double_t itscentertransz[fgklayernumber];
1478 itscentertransz[0] = fgkSSDLay5LadderLength
1479 - fgkLay5CenterITSPosition;
1480 itscentertransz[1] = fgkSSDLay6LadderLength
1481 - fgkLay6CenterITSPosition;
1482 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1483 + 0.5*fgkCoolingTubeSupportHeight;
1484 TGeoRotation* itscenterrot[3];
1485 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1486 itscenterrot[0]->SetAngles(90.,180.,-90.);
1487 itscenterrot[1]->SetAngles(0.,90.,0.);
1488 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1489 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1490 for(Int_t i=0; i<fgklayernumber; i++)
1491 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1493 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1494 - itscentertransz[i],itscenterrot[2]);
1495 TGeoRotation** locallayerrot[fgklayernumber];
1496 TGeoTranslation** locallayertrans[fgklayernumber];
1497 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1498 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1499 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1500 - fgkLay5CenterITSPosition);
1501 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1502 - fgkLay6CenterITSPosition);
1503 const Int_t kssdlayladdernumber[fgklayernumber] =
1504 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1505 for(Int_t i=0; i<fgklayernumber; i++){
1506 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1507 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1508 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1509 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1511 Double_t layerladderangleposition[fgklayernumber] =
1512 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1513 Double_t layerradius = 0.;
1514 for(Int_t i=0; i<fgklayernumber; i++){
1515 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1517 case 0: //Ladder of Layer5
1518 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1520 case 1: //Ladder of Layer6
1521 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1524 locallayerrot[i][j] = new TGeoRotation();
1525 locallayertrans[i][j] = new TGeoTranslation();
1526 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1527 locallayertrans[i][j]->SetTranslation(layerradius
1528 * CosD(90.0+j*layerladderangleposition[i]),
1530 * SinD(90.0+j*layerladderangleposition[i]),0.);
1531 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1532 *locallayerrot[i][j]);
1533 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1534 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1535 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1538 /////////////////////////////////////////////////////////////
1539 // Deallocating memory
1540 /////////////////////////////////////////////////////////////
1541 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1542 delete carbonfiberot[i];
1543 delete localcarbonfibersupportmatrix[i];
1545 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1546 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1547 delete localcarbonfiberjunctionmatrix[i][j];
1548 delete localcarbonfiberjunctionrot[i][j];
1549 delete localcarbonfiberjunctiontrans[i][j];
1551 delete [] localcarbonfiberjunctionmatrix[i];
1552 delete [] localcarbonfiberjunctionrot[i];
1553 delete [] localcarbonfiberjunctiontrans[i];
1555 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1556 delete localcarbonfiberlowersupportrans[i];
1557 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1558 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1559 delete localssdsensorsupportmatrix[i][j];
1560 delete localssdsensorsupportrot[i][j];
1561 delete localssdsensorsupportrans[i][j];
1563 delete [] localssdsensorsupportmatrix[i];
1564 delete [] localssdsensorsupportrot[i];
1565 delete [] localssdsensorsupportrans[i];
1567 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1568 delete localcoolingtubesupportmatrix[i];
1569 delete localcoolingtubesupportrot[i];
1570 delete localcoolingtubesupportrans[i];
1572 for(Int_t j=0; j<2; j++){
1573 delete localcoolingtubevect[j];
1574 delete localcoolingtubetrans[j];
1576 delete endladdermountingblockrot;
1577 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1578 for(Int_t i=0; i<fgkflexnumber; i++){
1579 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1580 delete localflexmatrix[i][j];
1581 delete [] localflexmatrix[i];
1583 delete localendlladdercoolingtuberot;
1584 for(Int_t i=0; i<2; i++){
1585 for(Int_t j=0; j<2; j++)
1586 delete localendlladdercoolingtubetrans[i][j];
1587 delete [] localendlladdercoolingtubetrans[i];
1590 delete localflexrot;
1591 delete localendflexrot;
1592 delete localendflexmatrix;
1593 for(Int_t i=0; i<fgkladdernumber; i++){
1594 delete localladdermothertrans[i];
1595 delete localladdermothercombitrans[i];
1597 delete localladdermotherrot;
1598 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1599 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
1600 delete localendladdercarbonfiberjunctionmatrix[i][j];
1601 delete localendladdercarbonfiberjunctionrot[i][j];
1602 delete localendladdercarbonfiberjunctiontrans[i][j];
1604 delete [] localendladdercarbonfiberjunctionmatrix[i];
1605 delete [] localendladdercarbonfiberjunctionrot[i];
1606 delete [] localendladdercarbonfiberjunctiontrans[i];
1607 delete localendladdercarbonfiberjunctionglobalrot[i];
1608 delete localendladdercarbonfiberjunctionglobaltrans[i];
1609 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1611 for(Int_t i=0; i<2; i++){
1612 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1613 delete [] localendladdercooltubetrans[i];
1615 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1616 delete localendladdercarbonfibertrans[i];
1617 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1618 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1619 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1620 delete localladdercablecombitransmatrix[i][j];
1621 delete []localladdercablecombitransmatrix[i];
1623 delete localendladdercliprot;
1624 delete localendladdercliptrans;
1625 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1626 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1627 delete localladdercablehmatrix[i][j];
1628 delete []localladdercablehmatrix[i];
1630 delete laddercablerot;
1631 delete laddercabletrans;
1632 delete laddercablecombitrans;
1633 delete localladdercablessdmodulematrix;
1634 delete localssdsensorrot;
1635 for(Int_t i=0; i<2; i++){
1636 delete localssdsensortrans[i];
1637 delete localssdsensorcombitrans[i];
1639 for(Int_t i=0; i<fgklayernumber; i++){
1640 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1641 delete locallayerrot[i][j];
1642 delete locallayertrans[i][j];
1643 delete locallayercombitrans[i][j];
1645 delete [] locallayerrot[i];
1646 delete [] locallayertrans[i];
1647 delete [] locallayercombitrans[i];
1648 delete localbeamaxistrans[i];
1650 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1651 for(Int_t i=0; i<fgkladdernumber; i++){
1652 for(Int_t j=0; j<fgkladdernumber; j++)
1653 delete ladderglobalmatrix[i][j];
1654 delete [] ladderglobalmatrix[i];
1656 /////////////////////////////////////////////////////////////
1657 fTransformationMatrices = kTRUE;
1659 ///////////////////////////////////////////////////////////////////////////////
1660 void AliITSv11GeometrySSD::CreateBasicObjects(){
1661 /////////////////////////////////////////////////////////////
1662 // Method generating the Objects of SSD Geometry
1663 /////////////////////////////////////////////////////////////
1665 ///////////////////////////////////
1667 /////////////////////////////////////////////////////////////
1668 // Carbon Fiber Support
1669 /////////////////////////////////////////////////////////////
1670 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1671 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1672 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
1673 /////////////////////////////////////////////////////////////
1674 // Carbon Fiber Junction
1675 /////////////////////////////////////////////////////////////
1676 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
1677 /////////////////////////////////////////////////////////////
1678 // Carbon Fiber Lower Support
1679 /////////////////////////////////////////////////////////////
1680 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1681 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1682 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1683 /////////////////////////////
1684 // SSD Sensor Support
1685 /////////////////////////////
1686 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1687 new TGeoVolume*[fgkssdsensorsupportnumber];
1688 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
1689 fgkSSDSensorSideSupportThickness[1]};
1690 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1691 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1692 fgkSSDSensorSideSupportHeight[i],
1693 fgkSSDSensorSideSupportWidth,
1694 sidesupporthickness);
1695 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1696 fgkSSDSensorCenterSupportHeight[i],
1697 fgkSSDSensorCenterSupportWidth,
1698 sidesupporthickness);
1700 /////////////////////////////////////////////////////////////
1701 // SSD Cooling Tube Support
1702 /////////////////////////////////////////////////////////////
1703 Int_t edgesnumber = 3;
1704 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1705 /////////////////////////////////////////////////////////////
1707 /////////////////////////////////////////////////////////////
1708 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1709 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1710 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1711 /////////////////////////////////////////////////////////////
1712 // SSD Cooling Block System
1713 /////////////////////////////////////////////////////////////
1714 fssdcoolingblocksystem = GetCoolingBlockSystem();
1715 /////////////////////////////////////////////////////////////
1717 /////////////////////////////////////////////////////////////
1718 CreateCoolingTubes();
1719 /////////////////////////////////////////////////////////////
1721 /////////////////////////////////////////////////////////////
1722 fssdstiffenerflex = GetSSDStiffenerFlex();
1723 fssdendflex = GetSSDEndFlex();
1724 ///////////////////////////////////
1725 // End Ladder Carbon Fiber Junction
1726 ///////////////////////////////////
1727 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1728 fendladdercarbonfiberjunction[i] =
1729 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1730 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1731 fendladdercarbonfiberjunction[i][0] =
1732 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
1733 fendladdercarbonfiberjunction[i][1] =
1734 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
1736 ///////////////////////////////////
1737 // End Ladder Mounting Block
1738 ///////////////////////////////////
1739 fendladdermountingblock = GetSSDMountingBlock();
1740 ///////////////////////////////////
1741 // End Ladder Mounting Block
1742 ///////////////////////////////////
1743 fendladdermountingblockclip = GetMountingBlockClip();
1744 ///////////////////////////////////
1746 ///////////////////////////////////
1747 TList* laddersupportlist = GetMountingBlockSupport(20);
1748 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1749 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1750 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1751 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
1752 /////////////////////////////////////////////////////////////
1753 // Deallocating memory
1754 /////////////////////////////////////////////////////////////
1755 delete carbonfibersupportlist;
1756 delete carbonfiberlowersupportlist;
1757 delete ssdhybridcomponentslist;
1758 delete laddersupportlist;
1759 /////////////////////////////////////////////////////////////
1760 fBasicObjects = kTRUE;
1762 /////////////////////////////////////////////////////////////////////////////////
1763 void AliITSv11GeometrySSD::SetSSDSensor(){
1764 ////////////////////////////////////////////////////////////////
1765 // Method generating SSD Sensors: it sets the private variables
1766 // fSSDSensor5, fSSDSensor6
1767 ////////////////////////////////////////////////////////////////
1768 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1769 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1770 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
1771 0.5*ssdsensitivewidth,
1772 0.5*fgkSSDSensorHeight,
1773 0.5*ssdsensitivelength);
1774 TGeoVolume* ssdsensorsensitiveLay5 =
1775 new TGeoVolume(fgkSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
1776 TGeoVolume* ssdsensorsensitiveLay6 =
1777 new TGeoVolume(fgkSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
1778 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1779 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
1780 TGeoBBox* ssdsensorinsensitiveshape[2];
1781 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
1782 0.5*fgkSSDSensorInsensitiveWidth,
1783 0.5*fgkSSDSensorHeight,
1784 0.5*fgkSSDSensorLength);
1785 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
1786 0.5*ssdsensitivewidth,
1787 0.5*fgkSSDSensorHeight,
1788 0.5*fgkSSDSensorInsensitiveWidth);
1789 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
1790 "SSDSensorInsensitive2"};
1791 TGeoVolume* ssdsensorinsensitive[2];
1792 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1793 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1795 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
1797 /////////////////////////////////////////////////////////////
1798 // Virtual Volume containing SSD Sensor
1799 /////////////////////////////////////////////////////////////
1800 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1801 0.5*fgkSSDSensorWidth,
1802 0.5*fgkSSDSensorHeight,
1803 0.5*fgkSSDSensorLength);
1804 fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
1806 fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
1808 /////////////////////////////////////////////////////////////
1809 for(Int_t i=0; i<4; i++){
1810 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1811 ssdsensorinsensitive[1],i<2?1:2,
1812 new TGeoTranslation(
1813 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1814 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1815 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1816 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1817 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1818 ssdsensorinsensitive[1],i<2?1:2,
1819 new TGeoTranslation(
1820 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1821 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1822 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1823 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1825 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1826 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
1828 ///////////////////////////////////////////////////////////////////////////////
1829 TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1830 /////////////////////////////////////////////////////////////
1831 // Method generating the Carbon Fiber Support
1832 /////////////////////////////////////////////////////////////
1833 const Int_t kvertexnumber = 4;
1834 const Int_t kshapesnumber = 2;
1835 TVector3** vertexposition[kshapesnumber];
1836 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1837 Double_t carbonfibersupportxaxisEdgeproj =
1838 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1839 * TMath::DegToRad());
1840 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1841 / fgkCarbonFiberSupportXAxisLength);
1842 /////////////////////
1843 //Vertex Positioning
1844 ////////////////////
1845 vertexposition[0][0] = new TVector3();
1846 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1847 fgkCarbonFiberSupportYAxisLength, 0);
1848 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1849 carbonfibersupportxaxisEdgeproj
1850 * TMath::Tan(theta), 0);
1851 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1852 - carbonfibersupportxaxisEdgeproj,
1853 fgkCarbonFiberSupportYAxisLength
1854 - vertexposition[0][2]->Y(), 0);
1855 ////////////////////////////////////////////////////
1856 //Setting the parameters for Isometry Transformation
1857 ////////////////////////////////////////////////////
1858 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1859 + fgkCarbonFiberSupportTopEdgeDist[0]
1860 + fgkCarbonFiberSupportWidth);
1861 Double_t* param = new Double_t[4];
1862 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1863 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1864 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1865 (GetReflection(vertexposition[0][j],param))->Y(), 0);
1866 const char* carbonfibersupportshapename[kshapesnumber] =
1867 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1868 const char* carbonfibersupportname[kshapesnumber] =
1869 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1870 TGeoArb8* carbonfibersupportshape[kshapesnumber];
1871 TGeoVolume* carbonfibersupport[kshapesnumber];
1872 TList* carbonfibersupportlist = new TList();
1873 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1874 Double_t carbonfibersupportheight =
1875 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1876 *TMath::DegToRad());
1877 for(Int_t i = 0; i< kshapesnumber; i++){
1878 carbonfibersupportshape[i] =
1879 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1880 carbonfibersupportshapename[i],i==0 ? 1: -1);
1881 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1882 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1883 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1884 carbonfibersupportlist->Add(carbonfibersupport[i]);
1886 /////////////////////////////////////////////////////////////
1887 // Deallocating memory
1888 /////////////////////////////////////////////////////////////
1889 for(Int_t i=0; i< kshapesnumber; i++){
1890 for(Int_t j=0; j< kvertexnumber; j++)
1891 delete vertexposition[i][j];
1892 delete [] vertexposition[i];
1895 /////////////////////////////////////////////////////////////
1896 return carbonfibersupportlist;
1898 /////////////////////////////////////////////////////////////////////////////////
1899 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
1900 /////////////////////////////////////////////////////////////
1901 // Method generating SSD Carbon Fiber Junction
1902 /////////////////////////////////////////////////////////////
1903 const Int_t kvertexnumber = 6;
1904 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
1905 Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1906 * TMath::DegToRad()),-1.,0.,0.};
1907 TVector3* vertex[kvertexnumber];
1908 vertex[0] = new TVector3();
1909 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
1910 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1911 * TMath::DegToRad()),
1912 fgkCarbonFiberJunctionEdge[0]
1913 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
1914 * TMath::DegToRad()), 0);
1915 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance,
1916 fgkCarbonFiberJunctionEdge[1], 0);
1917 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance, 0, 0);
1918 vertex[1] = GetReflection(vertex[5],reflectionparam);
1919 vertex[2] = GetReflection(vertex[4],reflectionparam);
1920 Double_t xvertexpoints[6], yvertexpoints[6];
1921 for(Int_t i=0; i<kvertexnumber; i++)
1922 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
1923 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
1924 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
1925 carbonfiberjunctionshape->DefineSection(1,0.5*width);
1926 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
1927 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
1928 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
1929 /////////////////////////////////////////////////////////////
1930 // Deallocating memory
1931 /////////////////////////////////////////////////////////////
1932 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
1933 /////////////////////////////////////////////////////////////
1934 return carbonfiberjunction;
1936 ////////////////////////////////////////////////////////////////////////////////
1937 TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
1938 /////////////////////////////////////////////////////////////
1939 // Method generating the Carbon Fiber Lower Support
1940 /////////////////////////////////////////////////////////////
1941 const Int_t kvertexnumber = 4;
1942 const Int_t kshapesnumber = 2;
1943 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
1944 fgkCarbonFiberLowerSupportWidth};
1945 TVector3** vertexposition[kshapesnumber];
1946 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
1947 new TVector3*[kvertexnumber];
1948 //First Shape Vertex Positioning
1949 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght, 0, 0);
1950 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
1951 - fgkCarbonFiberLowerSupportLowerLenght, 0, 0);
1952 vertexposition[0][2] = new TVector3();
1953 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength, 0, 0);
1954 //Second Shape Vertex Positioning
1955 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
1956 - fgkCarbonFiberLowerSupportVolumePosition[0])
1957 / fgkCarbonFiberTriangleLength);
1958 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
1959 vertexposition[0][0]->X()*TMath::Tan(theta)
1960 + fgkCarbonFiberLowerSupportVolumePosition[0], 0);
1961 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
1962 vertexposition[0][1]->X()*TMath::Tan(theta)
1963 + fgkCarbonFiberLowerSupportVolumePosition[0], 0);
1964 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0], 0);
1965 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
1966 fgkCarbonFiberLowerSupportVolumePosition[1], 0);
1967 const char* carbonfiberlowersupportshapename[kshapesnumber] =
1968 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
1969 const char* carbonfiberlowersupportname[kshapesnumber] =
1970 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
1971 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
1972 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
1973 TList* carbonfiberlowersupportlist = new TList();
1974 for(Int_t i = 0; i< kshapesnumber; i++){
1975 carbonfiberlowersupportshape[i] =
1976 GetArbShape(vertexposition[i],width,
1977 fgkCarbonFiberLowerSupportHeight,
1978 carbonfiberlowersupportshapename[i]);
1979 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
1980 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
1981 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
1982 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
1984 /////////////////////////////////////////////////////////////
1985 // Deallocating memory
1986 /////////////////////////////////////////////////////////////
1987 for(Int_t i=0; i< kshapesnumber; i++){
1988 for(Int_t j=0; j< kvertexnumber; j++)
1989 delete vertexposition[i][j];
1990 delete [] vertexposition[i];
1992 /////////////////////////////////////////////////////////////
1993 return carbonfiberlowersupportlist;
1995 ///////////////////////////////////////////////////////////////////////////////
1996 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
1997 Double_t width, const Double_t* thickness)const{
1998 /////////////////////////////////////////////////////////////
1999 // Method generating the Sensor Support
2000 /////////////////////////////////////////////////////////////
2001 const Int_t kvertexnumber = 6;
2002 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2003 TVector3* vertexposition[kvertexnumber];
2004 vertexposition[0] = new TVector3();
2005 vertexposition[1] = new TVector3(0.0,length,0);
2006 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y(),0);
2007 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0],0);
2008 vertexposition[4] = new TVector3(height,vertexposition[3]->Y(),0);
2009 vertexposition[5] = new TVector3(vertexposition[4]->X(),0,0);
2010 Double_t xvertexpoints[6], yvertexpoints[6];
2011 for(Int_t i=0; i<kvertexnumber; i++)
2012 xvertexpoints[i] = vertexposition[i]->X(),
2013 yvertexpoints[i] = vertexposition[i]->Y();
2014 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2015 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2016 ssdsensorsupportshape->DefineSection(1,0.5*width);
2017 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2018 ssdsensorsupportshape,fSSDSensorSupportMedium);
2019 /////////////////////////////////////////////////////////////
2020 // Deallocating memory
2021 /////////////////////////////////////////////////////////////
2022 for (Int_t i=0; i<kvertexnumber; i++)
2023 delete vertexposition[i];
2024 /////////////////////////////////////////////////////////////
2025 return ssdsensorsupport;
2027 ////////////////////////////////////////////////////////////////////////////////
2028 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2029 /////////////////////////////////////////////////////////////
2030 // Method generating the Cooling Tube Support
2031 /////////////////////////////////////////////////////////////
2032 if(nedges%2!=0) nedges--;
2033 const Int_t kvertexnumber = nedges+5;
2034 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2035 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2036 Double_t angle = 90.+phi;
2037 Double_t psi = 90.-phi;
2038 ///////////////////////////////////////
2039 // Vertex Positioning for TGeoXTru
2040 ///////////////////////////////////////
2041 TVector3** vertexposition = new TVector3*[kvertexnumber];
2043 Double_t router = fgkCoolingTubeSupportRmin/CosD(phi/nedges); // Recalc inner radius so that tube fits inside
2044 vertexposition[0] = new TVector3(router*CosD(angle),
2045 router*SinD(angle), 0);
2046 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2047 fgkCoolingTubeSupportRmax*SinD(angle),0);
2048 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2049 fgkCoolingTubeSupportRmax, 0);
2050 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2051 fgkCoolingTubeSupportRmax, 0);
2052 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2053 vertexposition[1]->Y(), 0);
2055 for(Int_t i=0; i<nedges; i++)
2056 vertexposition[i+5] =
2057 new TVector3(router*CosD(psi+i*(2.*phi/nedges)),
2058 router*SinD(psi+i*(2.*phi/nedges)), 0);
2059 ///////////////////////////////////////////////////////////////////////
2060 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2061 ///////////////////////////////////////////////////////////////////////
2062 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2063 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2064 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2065 for(Int_t i=0; i<kvertexnumber; i++){
2066 xvertexpoints[i] = vertexposition[i]->X();
2067 yvertexpoints[i] = vertexposition[i]->Y();
2069 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2071 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2072 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2073 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2074 coolingtubesupportarcshape,
2075 fSSDTubeHolderMedium);
2076 coolingtubesupportarc->SetLineColor(fColorG10);
2077 //////////////////////////////////////////////////////////////////////////
2078 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2079 //////////////////////////////////////////////////////////////////////////
2080 TGeoTubeSeg* coolingtubesupportsegshape =
2081 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2082 fgkCoolingTubeSupportRmax,
2083 0.5*fgkCoolingTubeSupportWidth,
2085 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2086 coolingtubesupportsegshape,
2087 fSSDTubeHolderMedium);
2088 coolingtubesupportseg->SetLineColor(fColorG10);
2089 //////////////////////////////////////////////////////////////////////////
2090 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2091 //////////////////////////////////////////////////////////////////////////
2092 Double_t* boxorigin = new Double_t[3];
2093 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2094 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2095 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2096 0.5*fgkCoolingTubeSupportHeight,
2097 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2098 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2099 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2100 coolingtubesupportbox->SetLineColor(fColorG10);
2101 //////////////////////////////////////////////////////////////////////////
2102 // Cooling Tube for Cooling Tube Support
2103 //////////////////////////////////////////////////////////////////////////
2104 TGeoXtru* coolingtubearcshape[2];
2105 coolingtubearcshape[0] = new TGeoXtru(2);
2106 Double_t* xvert = new Double_t[nedges+2];
2107 Double_t* yvert = new Double_t[nedges+2];
2108 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2109 ////////////////////////////////////////
2110 // Positioning the vertices for TGeoXTru
2111 ////////////////////////////////////////
2112 xvert[0] = 0., yvert[0] = 0.;
2113 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2114 for(Int_t i=0; i< nedges; i++)
2115 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2116 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2117 ////////////////////////////////////////
2118 // Defining TGeoXTru PolyGone
2119 ////////////////////////////////////////
2120 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2121 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2122 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2123 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2124 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2125 TGeoVolume* coolingtubearc[2];
2126 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2127 coolingtubearcshape[0],fSSDCoolingTubeWater);
2128 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2129 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2130 coolingtubearc[0]->SetLineColor(fColorWater);
2131 coolingtubearc[1]->SetLineColor(fColorPhynox);
2132 ////////////////////////////////////////////
2133 // Defining TGeoTubeSeg Part of Cooling Tube
2134 ////////////////////////////////////////////
2135 TGeoTubeSeg* coolingtubesegshape[2];
2136 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2137 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2138 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2139 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2140 TGeoVolume* coolingtubeseg[2];
2141 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2142 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2143 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2144 coolingtubesegshape[1],fSSDCoolingTubeWater);
2145 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2146 coolingtubeseg[1]->SetLineColor(fColorWater);
2147 /////////////////////////////////////////////////////////////
2148 // Virtual Volume containing Cooling Tube Support
2149 /////////////////////////////////////////////////////////////
2150 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2151 const Int_t kvirtualvertexnumber = 8;
2152 TVector3* virtualvertex[kvirtualvertexnumber];
2153 ////////////////////////////////////////
2154 // Positioning the vertices for TGeoXTru
2155 ////////////////////////////////////////
2156 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax, 0);
2157 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y(),0);
2158 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y(),0);
2159 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight,0);
2160 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y(),0);
2161 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y(),0);
2162 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y(),0);
2163 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y(),0);
2164 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2165 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2166 xmothervertex[i] = virtualvertex[i]->X(),
2167 ymothervertex[i] = virtualvertex[i]->Y();
2168 ////////////////////////////////////////
2169 // Defining TGeoXTru PolyGone
2170 ////////////////////////////////////////
2171 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2173 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2174 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2175 /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2176 virtualCoolingTubeSupportShape,fSSDAir); */
2177 TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
2179 ////////////////////////////////////////
2180 // Positioning Volumes in Virtual Volume
2181 ////////////////////////////////////////
2182 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2183 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2184 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2185 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2186 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2187 //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2188 //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2189 //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2190 //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2191 /////////////////////////////////////////////////////////////
2192 // Deallocating memory
2193 /////////////////////////////////////////////////////////////
2194 delete [] vertexposition;
2195 delete [] xvertexpoints;
2196 delete [] yvertexpoints;
2199 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2200 delete virtualvertex[i];
2201 /////////////////////////////////////////////////////////////
2202 return virtualcoolingtubesupport;
2204 /////////////////////////////////////////////////////////////////////////////////
2205 TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2206 /////////////////////////////////////////////////////////////
2207 // Method generating List containing SSD Hybrid Components
2208 /////////////////////////////////////////////////////////////
2209 TList* ssdhybridlist = new TList();
2210 const Int_t kssdstiffenernumber = 2;
2211 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2212 - 2.*fgkSSDModuleStiffenerPosition[1]
2213 - fgkSSDStiffenerWidth;
2214 Double_t ssdchipcablesradius[kssdstiffenernumber];
2215 for(Int_t i=0; i<kssdstiffenernumber; i++)
2216 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2217 - fgkSSDChipCablesHeight[0]
2218 - fgkSSDChipCablesHeight[1]);
2219 /////////////////////////////////////////////////////////////
2220 // Mother Volumes Containers
2221 /////////////////////////////////////////////////////////////
2222 const Int_t kmothernumber = 2;
2223 const Int_t kmothervertexnumber = 8;
2224 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2225 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2227 TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
2228 TGeoVolume* ssdhybridmother[kmothernumber][2];
2230 TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
2231 TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
2232 TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
2234 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2235 for(Int_t i=0; i<kmothernumber; i++){
2236 xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
2237 ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
2238 xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
2239 ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2240 -fgkSSDChipCablesHeight[i+2];
2242 xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
2243 ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
2244 xmothervertex[i][3] = xmothervertex[i][2];
2245 ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1]+fgkSSDTolerance;
2247 xmothervertex[i][4] = xmothervertex[i][2]-0.4;
2248 ymothervertex[i][4] = ymothervertex[i][3];
2249 xmothervertex[i][5] = xmothervertex[i][4];
2250 ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i]-fgkSSDTolerance;
2252 xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
2253 ymothervertex[i][6] = ymothervertex[i][5];
2255 xmothervertex[i][7] = xmothervertex[i][6];
2256 ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
2257 TGeoXtru *shape = new TGeoXtru(2);
2258 shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
2259 shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
2260 shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
2261 ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
2262 ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
2263 ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
2265 /////////////////////////////////////////////////////////////
2267 /////////////////////////////////////////////////////////////
2268 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2269 0.5*fgkSSDStiffenerLength,
2270 0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
2271 0.5*fgkSSDStiffenerHeight);
2272 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2273 fSSDStiffenerMedium);
2274 ssdstiffener->SetLineColor(fColorStiffener);
2276 ////////////////////////////
2277 // Capacitor 0603-2200 nF
2278 ///////////////////////////
2279 const Int_t knapacitor0603number = 5;
2280 TGeoBBox* capacitor0603mothershape = new TGeoBBox("Capacitor0603MotherShape",
2281 0.5*fgkSSDCapacitor0603Length + fgkSSDCapacitor0603CapLength,
2282 0.5*fgkSSDCapacitor0603Width,
2283 0.5*fgkSSDCapacitor0603Height);
2284 TGeoVolume* capacitor0603mother = new TGeoVolume("Capacitor0603Mother",capacitor0603mothershape,
2287 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
2288 0.5*fgkSSDCapacitor0603Length,
2289 0.5*fgkSSDCapacitor0603Width,
2290 0.5*fgkSSDCapacitor0603Height);
2291 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
2292 fSSDStiffener0603CapacitorMedium);
2293 capacitor0603->SetLineColor(fColorAl);
2294 TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.);
2295 capacitor0603mother->AddNode(capacitor0603,1,cap0603trans);
2297 TGeoBBox* capacitor0603capshape = new TGeoBBox("Capacitor0603CapShape",
2298 0.5*fgkSSDCapacitor0603CapLength,
2299 0.5*fgkSSDCapacitor0603Width,
2300 0.5*fgkSSDCapacitor0603Height);
2301 TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape,
2302 fSSDStiffenerCapacitorCapMedium);
2303 capacitor0603cap->SetLineColor(fColorNiSn);
2304 TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.);
2305 capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1);
2306 TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.);
2307 capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2);
2310 TGeoVolume* ssdchip = GetSSDChip();
2312 const Int_t knedges = 5;
2313 TGeoVolume *ssdchipcables[2];
2315 for(Int_t i=0; i<kmothernumber; i++){
2316 for(Int_t j=0; j<kssdstiffenernumber; j++){
2317 ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
2318 for(Int_t k=1; k<knapacitor0603number+1; k++){
2319 ssdhybridmother[i][j]->AddNode(capacitor0603mother,k,
2320 new TGeoCombiTrans("",
2321 -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
2322 -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
2323 (k-3.)/6*fgkSSDStiffenerLength,
2324 hybridmotherrotInv));
2328 GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
2329 for(Int_t k=0; k<fgkSSDChipNumber; k++){
2330 TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
2331 - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
2332 - fgkSSDChipCablesHeight[i+2],
2333 (k+0.5-fgkSSDChipNumber/2)*
2334 (fgkSSDChipLength + fgkSSDChipSeparationLength));
2335 TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
2336 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
2337 (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
2338 hybridmotherrotInv);
2339 for(Int_t j=0; j<kssdstiffenernumber; j++){
2340 ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
2341 ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
2344 // Final placement by assembly
2345 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
2346 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
2347 ssdhybridlist->Add(ssdhybridassembly[i]);
2349 /////////////////////////////////////////////////////////////
2350 // Mother Volume Containing Capacitor Part
2351 /////////////////////////////////////////////////////////////
2352 const Int_t kcapacitormothernumber = 8;
2353 Double_t xcapacitorvertex[kcapacitormothernumber];
2354 Double_t ycapacitorvertex[kcapacitormothernumber];
2355 ///////////////////////
2356 // Setting the vertices
2357 ///////////////////////
2358 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2359 xcapacitorvertex[1] = xcapacitorvertex[0];
2360 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2361 xcapacitorvertex[3] = xcapacitorvertex[2];
2362 xcapacitorvertex[4] = xcapacitorvertex[0];
2363 xcapacitorvertex[5] = xcapacitorvertex[0];
2364 xcapacitorvertex[6] = -xcapacitorvertex[0];
2365 xcapacitorvertex[7] = xcapacitorvertex[6];
2366 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2367 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2368 ycapacitorvertex[2] = ycapacitorvertex[1];
2369 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2370 ycapacitorvertex[4] = ycapacitorvertex[3];
2371 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2372 ycapacitorvertex[6] = ycapacitorvertex[5];
2373 ycapacitorvertex[7] = ycapacitorvertex[0];
2374 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2375 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2377 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2378 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2379 // TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2381 TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
2382 ////////////////////////////
2384 ///////////////////////////
2385 const Int_t kssdconnectorlayernumber = 3;
2386 TGeoBBox* ssdconnectorshape[kssdconnectorlayernumber];
2387 Double_t ssdConnectorThickness[kssdconnectorlayernumber]={fgkSSDConnectorAlHeight,fgkSSDConnectorNiHeight,fgkSSDConnectorSnHeight};
2389 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2390 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2391 + fgkSSDConnectorAlHeight};
2393 Double_t ssdconnectororigin[3] = {0,0,0.5*fgkSSDStiffenerHeight};
2394 const char* ssdconnectorname[kssdconnectorlayernumber] = {"SSDConnectorAl","SSDConnectorNi","SSDConnectorSn"};
2395 TGeoMedium *ssdConnectorMedium[kssdconnectorlayernumber]={fSSDAlTraceFlexMedium,fSSDStiffenerConnectorMedium,fSSDSn};
2396 TGeoVolume* ssdconnector[kssdconnectorlayernumber];
2397 for(Int_t i=0; i<kssdconnectorlayernumber; i++){
2398 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
2399 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2400 0.5*fgkSSDConnectorWidth,
2401 0.5*ssdConnectorThickness[i],
2402 ssdconnectororigin);
2403 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
2404 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2405 ssdConnectorMedium[i]);
2406 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorNiSn);
2408 const Int_t kssdconnectornumber = 4;
2409 TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
2410 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2411 + fgkSSDConnectorPosition[0]
2412 - fgkSSDConnectorSeparation
2413 - 1.5*fgkSSDConnectorLength,
2414 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2415 - fgkSSDConnectorPosition[1]
2416 - ssdconnectorshape[0]->GetDY(),0.0);
2417 ssdconnectortrans[1] = new TGeoTranslation(
2418 - ssdstiffenershape->GetDX()
2419 + fgkSSDConnectorPosition[0]
2420 - 0.5*fgkSSDConnectorLength,
2421 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2422 - fgkSSDConnectorPosition[1]
2423 - ssdconnectorshape[0]->GetDY(),0.0);
2424 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2425 - fgkSSDConnectorPosition[0]
2426 + fgkSSDConnectorSeparation
2427 + 1.5*fgkSSDConnectorLength,
2428 -(ssdstiffenershape->GetDY()
2429 - fgkSSDConnectorPosition[1]
2430 - ssdconnectorshape[0]->GetDY()),0.0);
2431 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2432 - fgkSSDConnectorPosition[0]
2433 + 0.5*fgkSSDConnectorLength,
2434 -(ssdstiffenershape->GetDY()
2435 - fgkSSDConnectorPosition[1]
2436 - ssdconnectorshape[0]->GetDY()),0.0);
2437 for(Int_t i=0; i<kssdconnectornumber; i++) {
2438 Int_t nlay = kssdconnectorlayernumber - 1;
2439 if (i == 1 || i == 2)
2441 for(Int_t j=0; j<nlay; j++)
2442 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2444 ////////////////////////////
2445 // Capacitor 1812-330 nF
2446 ///////////////////////////
2447 // Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
2448 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
2449 0.5*fgkSSDCapacitor1812Length,
2450 0.5*fgkSSDCapacitor1812Width,
2451 0.5*fgkSSDCapacitor1812Height);
2452 // ssdcapacitor1812origin);
2453 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2454 fSSDStiffener1812CapacitorMedium);
2455 capacitor1812->SetLineColor(fColorAl);
2456 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2457 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2458 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2459 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
2461 TGeoBBox* capacitor1812capshape = new TGeoBBox("Capacitor1812CapShape",
2462 0.5*fgkSSDCapacitor1812CapLength, 0.5*fgkSSDCapacitor1812Width,
2463 0.5*fgkSSDCapacitor1812Height);
2464 TGeoVolume* capacitor1812cap = new TGeoVolume("Capacitor1812Cap",capacitor1812capshape,
2465 fSSDStiffenerCapacitorCapMedium);
2466 capacitor1812cap->SetLineColor(fColorNiSn);
2467 TGeoTranslation* capacitor1812captrans1 = new TGeoTranslation(
2468 - capacitor1812shape->GetDX() - capacitor1812capshape->GetDX(),
2469 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2470 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2471 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2472 ssdhybridcapacitormother->AddNode(capacitor1812cap,1,capacitor1812captrans1);
2473 TGeoTranslation* capacitor1812captrans2 = new TGeoTranslation(
2474 capacitor1812shape->GetDX() + capacitor1812capshape->GetDX(),
2475 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2476 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2477 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2478 ssdhybridcapacitormother->AddNode(capacitor1812cap,2,capacitor1812captrans2);
2480 ////////////////////////////
2482 ////////////////////////////
2483 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
2484 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2485 - fgkSSDConnectorSeparation;
2486 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
2487 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
2488 Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2490 Double_t wireangle = TMath::ATan(wirex/wirey);
2491 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2492 fgkSSDWireRadius, 0.5*ssdwireradius);
2493 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2494 fSSDStiffenerHybridWireMedium);
2495 hybridwire->SetLineColor(fColorPhynox);
2496 TGeoCombiTrans* hybridwirecombitrans[2];
2497 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
2498 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2499 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
2500 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
2501 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
2502 ssdstiffenershape->GetDZ()
2503 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight+fgkSSDConnectorSnHeight,
2504 new TGeoRotation("HybridWireRot1",0.,90.,0.));
2505 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
2507 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2509 new TGeoRotation("HybridWireRot2",
2510 - wireangle*TMath::RadToDeg(),0.,0.));
2511 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2512 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2513 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
2514 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2515 ssdhybridlist->Add(ssdhybridcapacitormother);
2516 /////////////////////////////////////////////////////////////
2517 // Deallocating memory
2518 /////////////////////////////////////////////////////////////
2519 delete hybridwirecombitrans[0];
2520 delete hybridwirecombitrans[1];
2521 return ssdhybridlist;
2522 /////////////////////////////////////////////////////////////
2524 ///////////////////////////////////////////////////////////////////////////////
2525 TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2526 /////////////////////////////////////////////////////////////
2527 // SSD Cooling Block System
2528 /////////////////////////////////////////////////////////////
2529 // SSD Cooling Block and Cooling Tube Transformations
2530 /////////////////////////////////////////////////////////////
2531 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2532 localcoolingblockrot->SetAngles(0.,90.,0.);
2533 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
2534 TVector3* coolingblocktransvector;
2535 coolingblocktransvector = new TVector3(fgkCoolingTubeSeparation,
2537 - 2.*fgkSSDModuleStiffenerPosition[1]
2538 - fgkSSDCoolingBlockWidth, 0);
2539 const Int_t kcoolingblocktransnumber = 2;
2540 const Int_t kcoolingblocknumber = 4;
2541 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2542 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2543 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2544 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
2545 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2546 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X(),//+2*coolingtubedistance,
2547 j*coolingblocktransvector->Y(),
2548 - 0.5*(fgkSSDCoolingBlockHoleCenter
2549 + fgkCoolingTubeRmax));
2550 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
2553 TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
2554 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2555 /////////////////////////////////////////////////////////////
2556 // Adding Cooling block to mother volume
2557 /////////////////////////////////////////////////////////////
2558 for(Int_t i=0; i<kcoolingblocknumber; i++){
2559 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2561 /////////////////////////////////////////////////////////////
2562 // Deallocating memory
2563 /////////////////////////////////////////////////////////////
2564 delete coolingblocktransvector;
2565 delete localcoolingblockrot;
2567 return coolingsystemother;
2569 /////////////////////////////////////////////////////////////////////////////////
2570 TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
2571 /////////////////////////////////////////////////////////////
2573 /////////////////////////////////////////////////////////////
2574 const Int_t kssdflexlayernumber = 2;
2575 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2576 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2577 const Int_t kmothervertexnumber = 17;
2578 Double_t xmothervertex[kmothervertexnumber];
2579 Double_t ymothervertex[kmothervertexnumber];
2580 /////////////////////////////////////////////
2581 // Auxiliary variables for vertex positioning
2582 /////////////////////////////////////////////
2583 const Int_t kssdflexboxnumber = 5;
2584 Double_t ssdflexboxlength[kssdflexboxnumber];
2585 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
2586 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2587 * fgkSSDChipSeparationLength
2588 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2589 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
2590 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2591 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
2592 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
2593 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2594 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2595 - ssdflexboxlength[1];
2596 Double_t ssdflexboxwidth[kssdflexboxnumber];
2597 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2598 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2599 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2600 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2601 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
2602 ///////////////////////
2603 // Setting the vertices
2604 ///////////////////////
2605 xmothervertex[0] = 0.0;
2606 xmothervertex[1] = xmothervertex[0];
2607 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2608 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2609 + ssdflexboxlength[4];
2610 xmothervertex[4] = xmothervertex[3];
2611 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2612 xmothervertex[6] = xmothervertex[5];
2613 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2614 xmothervertex[8] = xmothervertex[7];
2615 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2616 xmothervertex[10] = xmothervertex[9];
2617 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2618 xmothervertex[12] = xmothervertex[11];
2619 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2620 xmothervertex[14] = xmothervertex[13];
2621 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2622 xmothervertex[16] = xmothervertex[15];
2623 ymothervertex[0] = 0.0;
2624 ymothervertex[1] = fgkSSDFlexWidth[1];
2625 ymothervertex[2] = fgkSSDFlexWidth[0];
2626 ymothervertex[3] = ymothervertex[2];
2627 ymothervertex[4] = ymothervertex[0];
2628 ymothervertex[5] = ymothervertex[4];
2629 ymothervertex[6] = ssdflexboxwidth[2];
2630 ymothervertex[7] = ymothervertex[6];
2631 ymothervertex[8] = ymothervertex[0];
2632 ymothervertex[9] = ymothervertex[8];
2633 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2634 ymothervertex[11] = ymothervertex[10];
2635 ymothervertex[12] = ymothervertex[0];
2636 ymothervertex[13] = ymothervertex[12];
2637 ymothervertex[14] = ymothervertex[7];
2638 ymothervertex[15] = ymothervertex[14];
2639 ymothervertex[16] = ymothervertex[0];
2640 /////////////////////////////////////////////////////////////
2641 // First Mother Volume containing SSDFlex
2642 /////////////////////////////////////////////////////////////
2643 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2644 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2646 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2647 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2648 TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2649 // TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2651 /////////////////////////////////////////////////////////////
2652 // SSDFlex Layer Shapes
2653 /////////////////////////////////////////////////////////////
2654 for(Int_t i=0; i<kssdflexlayernumber; i++){
2655 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2657 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2658 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2660 /////////////////////////////////////
2661 // Setting Layers into Mother Volume
2662 /////////////////////////////////////
2663 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2664 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2665 fSSDKaptonFlexMedium};
2666 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2667 "AlFlexLay2","KaptonFlexLay2"};
2668 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2669 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2670 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2671 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2672 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2673 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2674 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2675 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2676 + fgkSSDFlexHeight[1]));
2677 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2679 return ssdflexmother;
2681 /////////////////////////////////////////////////////////////////////////////////
2682 TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
2683 /////////////////////////////////////////////////////////////
2684 // Method generating SSD End Flex
2685 /////////////////////////////////////////
2686 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2687 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2688 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2689 * TMath::DegToRad()*ssdflexradiusmax
2690 - fgkSSDFlexLength[2]-TMath::Pi()
2691 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2692 - 0.1*fgkSSDFlexFullLength;
2693 const Int_t knedges = 20;
2694 const Int_t karcnumber = 2;
2695 TVector3* vertexposition[karcnumber*(knedges+1)];
2696 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2697 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2698 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2699 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2700 - 90.0*TMath::DegToRad()};
2701 TVector3* referencetrans[karcnumber];
2702 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2703 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2705 referencetrans[1] = new TVector3(referencetrans[0]->X()
2706 + fgkSSDFlexLength[2],
2707 - fgkSSDStiffenerHeight, 0);
2708 for(Int_t i=0; i<karcnumber; i++){
2709 for(Int_t j=0; j<knedges+1; j++){
2710 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2711 radius[i]*SinD(angle[i]), 0);
2712 angle[i] += deltangle[i]*(1.0-2.0*i);
2715 ///////////////////////
2716 // Setting the vertices
2717 ///////////////////////
2718 const Int_t kendflexlayernumber = 4;
2719 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2720 TVector3** vertex[kendflexlayernumber];
2721 for(Int_t i=0; i<kendflexlayernumber; i++)
2722 vertex[i] = new TVector3*[kendflexvertexnumber];
2723 TVector3* transvector[kendflexlayernumber+1];
2724 TVector3* deltatransvector = new TVector3();
2725 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2726 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2727 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2728 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2729 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2730 * CosD(fgkSSDFlexAngle),
2731 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2732 * SinD(fgkSSDFlexAngle),0.0);
2733 *transvector[i] = *transvector[i-1]+*deltatransvector;
2735 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2736 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2737 for(Int_t i=0; i<karcnumber; i++){
2738 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2739 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2740 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2744 for(Int_t i=0; i<kendflexlayernumber; i++){
2745 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y(),0);
2746 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y(),0);
2747 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2749 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2750 vertexposition[j]->Y()*ratioradius[0][i+1], 0);
2751 vertex[i][j+2]->RotateZ(referenceangle[0]);
2752 *vertex[i][j+2] += *referencetrans[0];
2753 vertex[i][4*(knedges+1)-j+1] =
2754 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2755 vertexposition[j]->Y()*ratioradius[0][i], 0);
2756 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2757 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2761 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2762 vertexposition[j]->Y()*ratioradius[1][i+1],0);
2763 vertex[i][j+2]->RotateZ(referenceangle[1]);
2764 *vertex[i][j+2] += *referencetrans[1];
2765 vertex[i][4*(knedges+1)-j+1] =
2766 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2767 vertexposition[j]->Y()*ratioradius[1][i],
2769 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2770 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2774 /////////////////////////////////////////////////////////////
2775 // First Mother Volume containing SSDEndFlex
2776 /////////////////////////////////////////////////////////////
2777 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2778 Double_t xmothervertex[kendflexvertexnumber];
2779 Double_t ymothervertex[kendflexvertexnumber];
2780 xmothervertex[0] = vertex[0][0]->X();
2781 ymothervertex[0] = vertex[0][0]->Y();
2782 for(Int_t i=1; i<kendflexvertexnumber; i++){
2783 if(i<2*(knedges+1)+2){
2784 xmothervertex[i] = vertex[3][i]->X();
2785 ymothervertex[i] = vertex[3][i]->Y();
2788 xmothervertex[i] = vertex[0][i]->X();
2789 ymothervertex[i] = vertex[0][i]->Y();
2792 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2793 xmothervertex,ymothervertex);
2794 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2795 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2796 // TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2797 // ssdendflexmothershape,fSSDAir);
2798 TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
2799 //////////////////////////////////////
2800 // End Flex TGeoXtru Layer Definition
2801 //////////////////////////////////////
2802 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2803 TGeoVolume* ssdendflex[kendflexlayernumber];
2804 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2805 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2806 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2807 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2808 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2809 fSSDKaptonFlexMedium};
2810 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2811 "AlEndFlexLay2","KaptonEndFlexLay2"};
2812 for(Int_t i=0; i<kendflexlayernumber; i++){
2813 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2814 xvertex[i][j] = vertex[i][j]->X();
2815 yvertex[i][j] = vertex[i][j]->Y();
2817 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2818 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2819 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2820 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2821 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2822 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2823 ssdendflexmother->AddNode(ssdendflex[i],1);
2825 /////////////////////////////////////////////////////////////
2826 // Deallocating memory
2827 /////////////////////////////////////////////////////////////
2828 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2829 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2830 for(Int_t i=0; i<kendflexlayernumber; i++){
2831 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2832 delete [] vertex[i];
2834 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2835 delete deltatransvector;
2836 /////////////////////////////////////////////////////////////
2837 //ssdendflexmother->CheckOverlaps(0.01);
2838 return ssdendflexmother;
2840 ///////////////////////////////////////////////////////////////////////////////
2841 TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
2842 /////////////////////////////////////////////////////////////
2843 // Method generating the Mounting Block
2844 /////////////////////////////////////////////////////////////
2845 const Int_t kvertexnumber = 8;
2846 Double_t xvertex[kvertexnumber];
2847 Double_t yvertex[kvertexnumber];
2848 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2849 xvertex[1] = xvertex[0];
2850 xvertex[2] = -xvertex[0];
2851 xvertex[3] = xvertex[2];
2852 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2853 - fgkSSDMountingBlockLength[2]);
2854 xvertex[5] = xvertex[4];
2855 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2856 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2857 - fgkSSDMountingBlockScrewHoleRadius[0];
2858 xvertex[7] = xvertex[6];
2859 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
2860 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
2861 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2862 yvertex[2] = yvertex[1];
2863 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2864 yvertex[4] = yvertex[3];
2865 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2866 - fgkSSDMountingBlockHeight[0];
2867 yvertex[6] = yvertex[5];
2868 yvertex[7] = yvertex[0];
2870 ///////////////////////////////////////////////////////////////////////
2871 // TGeoXTru Volume definition for Mounting Block Part
2872 ///////////////////////////////////////////////////////////////////////
2873 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2874 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2875 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2876 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
2877 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
2878 ssdmountingblockshape,
2879 fSSDMountingBlockMedium);
2880 ssdmountingblock->SetLineColor(fColorG10);
2881 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2882 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2883 TGeoRotation* mountingblockrot = new TGeoRotation();
2884 mountingblockrot->SetAngles(90.,180.,-90.);
2885 mountingblockcombitrans->SetRotation(*mountingblockrot);
2886 /////////////////////////////////////////////////////////////
2887 // Generating the Mounting Block Screw Vertices
2888 /////////////////////////////////////////////////////////////
2889 const Int_t kscrewvertexnumber = 15;
2890 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
2891 - fgkSSDMountingBlockScrewHoleEdge)
2892 / fgkSSDMountingBlockScrewHoleRadius[0])
2893 * TMath::RadToDeg();
2894 Double_t phi0 = 90.+alpha;
2895 Double_t phi = 270.-2*alpha;
2896 Double_t deltaphi = phi/kscrewvertexnumber;
2897 TVector3* screwvertex[kscrewvertexnumber+1];
2898 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
2899 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
2900 *CosD(phi0+i*deltaphi),
2901 fgkSSDMountingBlockScrewHoleRadius[0]
2902 *SinD(phi0+i*deltaphi), 0);
2903 Double_t xscrewvertex[kscrewvertexnumber+6];
2904 Double_t yscrewvertex[kscrewvertexnumber+6];
2905 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
2906 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
2907 - fgkSSDMountingBlockScrewHoleEdge);
2908 xscrewvertex[1] = xscrewvertex[0];
2909 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2910 xscrewvertex[2] = screwvertex[0]->X();
2911 yscrewvertex[2] = yscrewvertex[1];
2912 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
2913 xscrewvertex[i+3] = screwvertex[i]->X();
2914 yscrewvertex[i+3] = screwvertex[i]->Y();
2916 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2917 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
2918 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
2919 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
2920 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
2921 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
2922 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
2923 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
2924 + fgkSSDMountingBlockHeight[2]);
2925 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
2926 ssdmountingblockscrewshape,
2927 fSSDMountingBlockMedium);
2928 ssdmountingblockscrew->SetLineColor(fColorG10);
2929 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
2930 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
2931 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2933 0.5*fgkSSDMountingBlockHeight[0]
2934 - fgkSSDMountingBlockHeight[2]
2935 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2936 + fgkSSDMountingBlockHeight[2]
2938 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2939 -0.5*fgkSSDMountingBlockScrewHoleEdge,
2941 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2942 +fgkSSDMountingBlockHeight[2]
2944 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2946 - 0.5*fgkSSDMountingBlockHeight[0]
2947 + fgkSSDMountingBlockHeight[2]
2948 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2949 + fgkSSDMountingBlockHeight[2]
2951 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2954 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2955 + fgkSSDMountingBlockHeight[2]
2957 TGeoRotation* ssdmountingblockscrewrot[4];
2958 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
2959 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
2960 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
2961 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
2962 for(Int_t i=1; i<4; i++)
2963 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
2964 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
2965 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
2966 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
2967 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
2968 + xvertex[0],yscrewvertex[1]
2969 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2970 + fgkSSDMountingBlockHeight[2]
2972 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
2973 for(Int_t i=0; i<4; i++){
2974 ssdmountingblockscrewmatrix[i] =
2975 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
2976 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
2978 ///////////////////////////////////////////////////////////////////////
2979 // TGeoXtru for Mother Volume
2980 ///////////////////////////////////////////////////////////////////////
2981 const Int_t kvertexmothernumber = 12;
2982 Double_t xmothervertex[kvertexmothernumber];
2983 Double_t ymothervertex[kvertexmothernumber];
2984 for(Int_t i=0; i<6; i++){
2985 xmothervertex[i] = xvertex[i];
2986 ymothervertex[i] = yvertex[i];
2988 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
2989 ymothervertex[6] = ymothervertex[5];
2990 xmothervertex[7] = xmothervertex[6];
2991 ymothervertex[7] = ymothervertex[4] - fgkSSDTolerance;
2992 xmothervertex[8] = xmothervertex[7]
2993 + 0.5*(fgkSSDMountingBlockLength[1]
2994 - fgkSSDMountingBlockLength[2]);
2995 ymothervertex[8] = ymothervertex[7];
2996 xmothervertex[9] = xmothervertex[8];
2997 ymothervertex[9] = ymothervertex[2];
2998 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
2999 ymothervertex[10] = ymothervertex[1];
3000 xmothervertex[11] = xmothervertex[10];
3001 ymothervertex[11] = ymothervertex[0];
3002 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3003 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3004 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3005 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3006 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3007 ssdmountingblockmothershape,
3009 /////////////////////////////////////////////////////////////
3010 // Placing the Volumes into Mother Volume
3011 /////////////////////////////////////////////////////////////
3012 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3013 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3014 for(Int_t i=0; i<4; i++)
3015 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3016 ssdmountingblockscrewmatrix[i]);
3017 /////////////////////////////////////////////////////////////
3018 // Deallocating memory
3019 /////////////////////////////////////////////////////////////
3020 delete mountingblockrot;
3021 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3022 delete ssdmountingblockglobalrot;
3023 delete ssdmountingblockglobaltrans;
3024 /////////////////////////////////////////////////////////////
3025 return ssdmountingblockmother;
3027 ///////////////////////////////////////////////////////////////////////////////
3028 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3029 /////////////////////////////////////////////////////////////
3030 // Method generating the Mounting Block Clip
3031 /////////////////////////////////////////////////////////////
3032 const Int_t kmothervertexnumber = 10;
3033 Double_t xmothervertex[kmothervertexnumber];
3034 Double_t ymothervertex[kmothervertexnumber];
3035 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3036 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3037 xmothervertex[1] = xmothervertex[0];
3038 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3039 - fgkMountingBlockClibScrewRadius);
3040 xmothervertex[3] = xmothervertex[2];
3041 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3042 xmothervertex[5] = xmothervertex[4];
3043 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3044 xmothervertex[7] = xmothervertex[6];
3045 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3046 xmothervertex[9] = xmothervertex[8];
3047 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
3048 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
3049 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3050 ymothervertex[2] = ymothervertex[1];
3051 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3052 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3053 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3054 ymothervertex[4] = ymothervertex[3];
3055 ymothervertex[5] = ymothervertex[2];
3056 ymothervertex[6] = ymothervertex[5];
3057 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3058 ymothervertex[8] = ymothervertex[7];
3059 ymothervertex[9] = ymothervertex[0];
3061 ///////////////////////////////////////////////////////////////////////
3062 // TGeoXTru Volume definition for Mounting Block Clip Part
3063 ///////////////////////////////////////////////////////////////////////
3064 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3065 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3066 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3067 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3068 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3069 ssdmountingblockclipshape,fSSDAir);
3070 ssdmountingblockclip->SetLineColor(4);
3071 ///////////////////////////////////////////////////////////////////////
3072 // TGeoXTru Volume definition for Clip
3073 ///////////////////////////////////////////////////////////////////////
3074 const Int_t kclipvertexnumber = 6;
3075 Double_t xclipvertex[kclipvertexnumber];
3076 Double_t yclipvertex[kclipvertexnumber];
3077 xclipvertex[0] = xmothervertex[0];
3078 xclipvertex[1] = xclipvertex[0];
3079 xclipvertex[2] = xmothervertex[6];
3080 xclipvertex[3] = xclipvertex[2];
3081 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3082 xclipvertex[5] = xclipvertex[4];
3083 yclipvertex[0] = ymothervertex[0];
3084 yclipvertex[1] = ymothervertex[1];
3085 yclipvertex[2] = yclipvertex[1];
3086 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3087 yclipvertex[4] = yclipvertex[3];
3088 yclipvertex[5] = yclipvertex[0];
3089 TGeoXtru* clipshape = new TGeoXtru(2);
3090 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3091 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3092 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3093 + fgkMountingBlockClibWidth);
3094 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3095 clip->SetLineColor(18);
3096 ///////////////////////////////////////////////////////////////////////
3097 // Ladder Support Piece
3098 ///////////////////////////////////////////////////////////////////////
3099 const Int_t ksupportvertexnumber = 4;
3100 Double_t xsupportvertex[ksupportvertexnumber];
3101 Double_t ysupportvertex[ksupportvertexnumber];
3102 xsupportvertex[0] = xclipvertex[5];
3103 xsupportvertex[1] = xsupportvertex[0];
3104 xsupportvertex[2] = xmothervertex[9];
3105 xsupportvertex[3] = xsupportvertex[2];
3106 ysupportvertex[0] = yclipvertex[0];
3107 ysupportvertex[1] = yclipvertex[3];
3108 ysupportvertex[2] = ysupportvertex[1];
3109 ysupportvertex[3] = ysupportvertex[0];
3110 TGeoXtru* supportshape = new TGeoXtru(2);
3111 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3112 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3113 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3114 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3115 support->SetLineColor(9);
3116 ///////////////////////////////////////////////////////////////////////
3117 // TGeoXTru Volume definition for Screw
3118 ///////////////////////////////////////////////////////////////////////
3119 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3120 0.5*fgkMountingBlockClibScrewRadius};
3121 Int_t edgesnumber[2] = {50,6};
3122 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3123 +0.5*(ymothervertex[3]-ymothervertex[2])};
3124 TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3125 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3126 clipscrew->SetLineColor(12);
3127 TGeoRotation* screwrot = new TGeoRotation();
3128 screwrot->SetAngles(0.,90.,0.);
3129 TGeoTranslation* screwtrans = new TGeoTranslation();
3130 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3131 0.5*(ymothervertex[3]+ymothervertex[2]),
3132 0.5*fgkSSDMountingBlockWidth+
3133 -0.5*fgkMountingBlockSupportWidth[0]);
3134 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3135 ///////////////////////////////////////////////////////////////////////
3136 // Placing the Volumes
3137 ///////////////////////////////////////////////////////////////////////
3138 ssdmountingblockclip->AddNode(clip,1);
3139 ssdmountingblockclip->AddNode(support,1);
3140 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3141 /////////////////////////////////////////////////////////////
3142 // Deallocating memory
3143 /////////////////////////////////////////////////////////////
3146 /////////////////////////////////////////////////////////////
3147 return ssdmountingblockclip;
3149 ///////////////////////////////////////////////////////////////////////////////
3150 void AliITSv11GeometrySSD::CreateCoolingTubes() {
3151 /////////////////////////////////////////////////////////////
3152 // Method generating the Cooling Tube
3153 // sets fcoolingtube and returns list for endladdercoolingtube
3154 /////////////////////////////////////////////////////////////
3155 TGeoTube *coolingtubeshape[2];
3156 // Ladder Cooling Tubes
3158 // MvL: Simplified cooling tubes
3159 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
3160 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
3162 // End Ladder Cooling Tubes
3163 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3164 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3165 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3167 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
3168 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3169 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
3170 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3171 endladdercoolingtubeshape[0][0]->GetDz());
3172 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3173 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
3174 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3175 endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
3176 // Ladder Cooling Tubes
3177 TGeoVolume* coolingtube[2];
3178 coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
3179 coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
3180 coolingtube[0]->SetLineColor(fColorPhynox);
3181 coolingtube[1]->SetLineColor(fColorWater);
3183 // End Ladder Cooling Tubes
3184 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3185 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3186 endladdercoolingtube[i] = new TGeoVolume*[2];
3187 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3188 endladdercoolingtubeshape[0][0],
3189 fSSDCoolingTubePhynox);
3190 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3191 endladdercoolingtubeshape[0][1],
3192 fSSDCoolingTubeWater);
3193 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3194 endladdercoolingtubeshape[1][0],
3195 fSSDCoolingTubePhynox);
3196 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3197 endladdercoolingtubeshape[1][1],
3198 fSSDCoolingTubeWater);
3199 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3200 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3201 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3204 /////////////////////////////////////////////////////////////
3205 // Virtual Volume containing Cooling Tubes
3206 /////////////////////////////////////////////////////////////
3207 // Ladder Cooling Tubes
3208 TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
3209 coolingtubeshape[0]->GetRmax(),
3210 coolingtubeshape[0]->GetDz());
3211 fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
3212 fcoolingtube->AddNode(coolingtube[0],1);
3213 fcoolingtube->AddNode(coolingtube[1],1);
3215 // End Ladder Cooling Tubes
3216 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3217 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3218 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3219 endladdercoolingtubeshape[i][0]->GetRmax(),
3220 endladdercoolingtubeshape[i][0]->GetDz());
3221 fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3222 endladdervirtualcoolingtubeshape[0],
3224 fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3225 endladdervirtualcoolingtubeshape[1],
3227 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3228 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3229 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3230 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3232 ///////////////////////////////////////////////////////////////////////////////
3233 TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
3234 /////////////////////////////////////////////////////////////
3235 // Method generating SSD Cooling Block
3236 /////////////////////////////////////////////////////////////
3237 const Int_t kvertexnumber = 8;
3238 ///////////////////////////////////////
3239 // Vertex Positioning for TGeoXTru
3240 ///////////////////////////////////////
3241 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3242 vertexposition[0] = new TVector3(0.0,0.0, 0.);
3243 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1],0);
3244 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3245 vertexposition[1]->Y(),0);
3246 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3247 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2],0);
3248 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y(),0);
3249 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3250 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1],0);
3251 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3252 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3253 - fgkSSDCoolingBlockHoleLength[0]
3254 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3255 fgkSSDCoolingBlockHeight[0]
3256 - fgkSSDCoolingBlockHoleRadius[1],
3257 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0], 0);
3258 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3259 - fgkSSDCoolingBlockHoleLength[0]),
3260 vertexposition[6]->Y(), 0);
3261 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3262 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3263 Double_t phi = 180.-alpha;
3264 Double_t psi = 180.+2.*alpha;
3265 Double_t deltapsi = psi/nedges;
3266 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3267 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3268 fgkSSDCoolingBlockHoleCenter, 0);
3269 for(Int_t i=0; i<nedges+1; i++){
3270 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3271 radius*SinD(phi+i*deltapsi),
3273 *vertexposition[kvertexnumber+i] += (*transvector);
3275 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3276 for(Int_t i=0; i<kvertexnumber; i++)
3277 vertexposition[kvertexnumber+nedges+1+i] =
3278 GetReflection(vertexposition[kvertexnumber-1-i],param);
3279 ///////////////////////////////////////////////////////////////////////
3280 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3281 ///////////////////////////////////////////////////////////////////////
3282 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3283 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3284 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3285 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3286 xvertexpoints[i] = vertexposition[i]->X();
3287 yvertexpoints[i] = vertexposition[i]->Y();
3289 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3291 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3292 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3293 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3294 ssdcoolingblockshape,
3295 fSSDAlCoolBlockMedium);
3296 ssdcoolingblock->SetLineColor(fColorAl);
3297 /////////////////////////////////////////////////////////////
3298 // Deallocating memory
3299 /////////////////////////////////////////////////////////////
3300 delete [] vertexposition;
3301 delete [] xvertexpoints;
3302 delete [] yvertexpoints;
3303 /////////////////////////////////////////////////////////////
3304 return ssdcoolingblock;
3306 /////////////////////////////////////////////////////////////////////////////////
3307 void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
3308 ///////////////////////////////////////////////////////
3309 static const Int_t kssdchipcablesnumber = 2; // Number of cables: left and right
3310 static const Int_t kssdchipcableslaynumber = 2; // Number of layers: Al and Kapton
3311 static const Int_t kvertexnumber = 4*(nedges+1)+4;
3312 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3313 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3314 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
3315 - fgkSSDChipCablesHeight[0]
3316 - fgkSSDChipCablesHeight[1]);
3317 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3318 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3319 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3320 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3321 - ssdchipcablesradius[0]
3322 - fgkSSDChipCablesWidth[1]
3323 - fgkSSDChipCablesWidth[2]);
3324 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3325 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3326 + fgkSSDChipCablesHeight[1]
3327 + fgkSSDSensorHeight);
3328 ///////////////////////////////////////////////////////
3329 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3330 ///////////////////////////////////////////////////////
3331 TVector3** vertexposition[kssdchipcableslaynumber];
3332 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3333 new TVector3*[4*(nedges+1)+4];
3335 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3336 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3337 / ssdchipcablesradius[0];
3338 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3339 / ssdchipcablesradius[0];
3340 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3341 + fgkSSDChipCablesHeight[1])
3342 / ssdchipcablesradius[0];
3343 Double_t phi = 180.;
3344 Double_t deltaphi = 180./nedges;
3345 Double_t angle = 0.0;
3347 Double_t xvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3348 Double_t yvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3350 TVector3* vertex = new TVector3();
3351 TVector3* transvector[kssdchipcableslaynumber];
3352 transvector[0] = new TVector3(fgkSSDChipWidth,
3353 SSDChipCablesHeight-ssdchipcablesradius[0], 0);
3354 transvector[1] = new TVector3();
3355 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
3356 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
3357 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
3358 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3359 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3360 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3361 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3362 transvector[1]->SetY(ssdchipcablesradius[0]
3363 + fgkSSDChipCablesHeight[0]
3364 + fgkSSDChipCablesHeight[1]);
3365 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3366 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
3367 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1], 0);
3368 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
3369 - i*fgkSSDChipCablesHeight[0], 0);
3370 vertexposition[i][2*(nedges+1)+2] =
3371 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3372 + fgkSSDChipCablesWidth[1]
3373 + fgkSSDChipCablesWidth[2],
3374 ((1.-i)*fgkSSDChipCablesHeight[i]
3375 + fgkSSDChipCablesHeight[1]), 0);
3376 vertexposition[i][2*(nedges+1)+3] =
3377 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3378 vertexposition[i][2*(nedges+1)+2]->Y()
3379 - fgkSSDChipCablesHeight[i], 0);
3380 for(Int_t j=0; j<nedges+1; j++){
3381 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3382 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3383 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3384 vertexposition[0][(nedges+1)*i+j+2] =
3385 new TVector3(*vertex+*transvector[i]);
3386 vertexposition[1][(nedges+1)*i+j+2] =
3387 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3388 vertex->Y()*ratio[2*i]+transvector[i]->Y(), 0);
3389 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3390 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3391 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3392 new TVector3(vertex->X()*ratio[2*i+1]
3393 + transvector[i]->X(),
3394 vertex->Y()*ratio[2*i+1]
3395 + transvector[i]->Y(), 0);
3398 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3399 for(Int_t j=0; j<kvertexnumber; j++){
3400 xvertexpoints[i][j] = vertexposition[i][j]->X();
3401 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3403 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3404 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3405 xvertexpoints[i],yvertexpoints[i]);
3406 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3407 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3408 ssdchipcable[kssdchipcablesnumber*k+i] =
3409 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3410 ssdchipcableshape[kssdchipcablesnumber*k+i],
3411 (kssdchipcablesnumber*k+i)%2==0?
3412 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3413 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3415 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3416 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3418 /////////////////////////////////////////////////////////////
3419 // Mother Volume definition
3420 /////////////////////////////////////////////////////////////
3421 static const Int_t kmothervertexnumber = 8;
3422 Double_t xmothervertex[kmothervertexnumber];
3423 Double_t ymothervertex[kmothervertexnumber];
3424 xmothervertex[0] = xvertexpoints[0][1];
3425 ymothervertex[0] = yvertexpoints[0][1];
3426 xmothervertex[1] = xvertexpoints[0][2+nedges/2];
3427 ymothervertex[1] = yvertexpoints[0][1];
3428 xmothervertex[2] = xvertexpoints[0][2+nedges/2];
3429 ymothervertex[2] = yvertexpoints[0][2+nedges];
3430 xmothervertex[3] = xvertexpoints[0][3+nedges];
3431 ymothervertex[3] = yvertexpoints[0][3+nedges];
3432 xmothervertex[4] = xvertexpoints[0][3+2*nedges];
3433 ymothervertex[4] = yvertexpoints[0][3+2*nedges]+fgkSSDTolerance;
3434 xmothervertex[5] = xvertexpoints[0][4+2*nedges];
3435 ymothervertex[5] = yvertexpoints[0][4+2*nedges]+fgkSSDTolerance;
3436 xmothervertex[6] = xvertexpoints[1][5+2*nedges];
3437 ymothervertex[6] = yvertexpoints[1][5+2*nedges];
3438 xmothervertex[7] = xvertexpoints[0][1];
3439 ymothervertex[7] = yvertexpoints[1][5+2*nedges];
3440 TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
3441 ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3442 ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3443 ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3445 cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
3446 cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
3448 cableL->AddNode(ssdchipcable[0],1);
3449 cableL->AddNode(ssdchipcable[1],1);
3450 cableR->AddNode(ssdchipcable[2],1);
3451 cableR->AddNode(ssdchipcable[3],1);
3453 /////////////////////////////////////////////////////////////
3454 // Deallocating memory
3455 /////////////////////////////////////////////////////////////
3456 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3457 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3459 /////////////////////////////////////////////////////////////
3461 //_____________________________________________________________________________
3462 TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
3463 /////////////////////////////////////////////////////////////
3464 // SSD Chip Assembly Generation
3465 /////////////////////////////////////////////////////////////
3466 TGeoBBox* ssdchipcompshape[2];
3467 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3468 0.5*fgkSSDChipLength,
3469 0.5*fgkSSDChipWidth,
3470 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3471 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3472 0.5*fgkSSDChipLength,
3473 0.5*fgkSSDChipWidth,
3474 0.5*fgkSSDChipGlueHeight);
3475 TGeoVolume* ssdchipcomp[2];
3476 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3477 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3478 fSSDChipGlueMedium);
3479 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3480 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3481 TGeoTranslation* ssdchipcomptrans[2];
3482 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3483 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3484 /////////////////////////////////////////////////////////////
3485 // Virtual Volume containing SSDChip
3486 /////////////////////////////////////////////////////////////
3487 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3488 0.5*fgkSSDChipWidth,
3489 0.5*fgkSSDChipHeight);
3490 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
3491 /////////////////////////////////////////////////////////////
3492 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3495 /////////////////////////////////////////////////////////////////////////////////
3496 TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
3497 /////////////////////////////////////////////////////////////
3498 // Method returning a List containing pointers to Ladder Cable Volumes
3500 // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
3501 // each contains 2 volumes, one for polyamide and one for aluminium
3502 /////////////////////////////////////////////////////////////
3503 const Int_t kladdercablesegmentnumber = 2;
3504 /////////////////////////////////////////
3505 // LadderSegmentBBox Volume
3506 /////////////////////////////////////////
3507 static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
3508 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3509 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3512 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3513 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3514 static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3516 static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
3517 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3518 0.5*fgkSSDFlexWidth[0],
3519 0.5*fgkSSDLadderCableWidth,
3520 0.5*fgkSSDLadderCableHeight[0]),
3521 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3522 0.5*fgkSSDFlexWidth[0],
3523 0.5*fgkSSDLadderCableWidth,
3524 fgkSSDLadderCableHeight[0]
3525 +0.5*fgkSSDLadderCableHeight[1])
3527 static TGeoVolume* laddercablesegmentbboxassembly = new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
3528 static TGeoVolume* laddercablesegmentarbassembly =
3529 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3531 static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3532 static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3534 if (laddercablesegmentbboxshape[0] == 0) {
3535 // Initialise static shapes and volumes
3536 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3537 new TGeoBBox(laddercablesegmentbboxshapename[i],
3538 0.5*fgkSSDFlexWidth[0],
3539 0.5*fgkSSDLadderCableWidth,
3540 0.5*fgkSSDLadderCableHeight[i]);
3542 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3543 laddercablesegmentbbox[i] =
3544 new TGeoVolume(laddercablesegmentbboxname[i],
3545 laddercablesegmentbboxshape[i],
3546 (i==0?fSSDAlTraceLadderCableMedium:
3547 fSSDKaptonLadderCableMedium));
3548 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3552 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3553 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3554 laddercablesegmentbboxtrans[i]);
3555 /////////////////////////////////////////
3556 // LadderSegmentArb8 Volume
3557 /////////////////////////////////////////
3558 const Int_t kvertexnumber = 4;
3559 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3560 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3561 new TVector3*[kvertexnumber];
3562 //Shape Vertex Positioning
3563 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3564 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0], 0);
3565 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3566 i*fgkSSDFlexHeight[0], 0);
3567 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3568 + fgkSSDFlexHeight[1]
3569 + i*fgkSSDFlexHeight[0], 0);
3570 laddercablesegmentvertexposition[i][3] =
3571 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3572 laddercablesegmentvertexposition[i][2]->Y(), 0);
3574 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3575 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3576 const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3577 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3579 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3580 GetArbShape(laddercablesegmentvertexposition[i],
3581 laddercablesegmentwidth[i],
3582 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3583 laddercablesegmentarbshapename[i]);
3584 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3585 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3587 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3588 laddercablesegmentarb[i] =
3589 new TGeoVolume(laddercablesegmentarbname[i],
3590 laddercablesegmentarbshape[i],
3591 (i==0?fSSDAlTraceLadderCableMedium:
3592 fSSDKaptonLadderCableMedium));
3593 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3596 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3597 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3599 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3601 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3602 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3603 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3604 + fgkSSDFlexWidth[0],0.,0.,
3605 new TGeoRotation((*laddercablesegmentarbrot[1])
3606 *(*laddercablesegmentarbrot[0])));
3607 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3608 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3609 laddercablesegmentarbcombitrans);
3610 } // End of static initialisations
3611 /////////////////////////////////////////
3612 // End Ladder Cable Volume
3613 // Note: this part depends explicitly on the length passed as an argument to the function
3614 /////////////////////////////////////////
3615 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3616 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3617 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3618 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3619 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3620 0.5*ssdendladdercablelength,
3621 0.5*fgkSSDLadderCableWidth,
3622 0.5*fgkSSDLadderCableHeight[i]);
3623 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3624 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3625 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3626 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3627 ladderendcablesegmentbbox[i] =
3628 new TGeoVolume(ladderendcablesegmentbboxname[i],
3629 ladderendcablesegmentbboxshape[i],
3630 (i==0?fSSDAlTraceLadderCableMedium:
3631 fSSDKaptonLadderCableMedium));
3632 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3635 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3636 ladderendcablesegmentbboxtrans[0] =
3637 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
3638 0.5*ssdendladdercablelength,
3639 0.5*fgkSSDLadderCableWidth,
3640 0.5*fgkSSDLadderCableHeight[0]);
3641 ladderendcablesegmentbboxtrans[1] =
3642 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
3643 0.5*ssdendladdercablelength,
3644 0.5*fgkSSDLadderCableWidth,
3645 fgkSSDLadderCableHeight[0]
3646 +0.5*fgkSSDLadderCableHeight[1]);
3647 TGeoVolume* ladderendcablesegmentbboxassembly =
3648 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
3649 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3650 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
3651 ladderendcablesegmentbboxtrans[i]);
3652 /////////////////////////////////////////
3653 TList* laddercablesegmentlist = new TList();
3654 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
3655 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
3656 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
3657 return laddercablesegmentlist;
3660 /////////////////////////////////////////////////////////////////////////////////
3661 TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
3662 /////////////////////////////////////////////////////////////
3663 // Method generating Ladder Cable of given length (n modules + end)
3664 // Called by GetLadderCableAssembly
3665 /////////////////////////////////////////////////////////////
3666 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
3667 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
3668 for(Int_t i=0; i<n; i++){
3669 TGeoTranslation* laddercabletrans = new TGeoTranslation(
3670 i*(fgkCarbonFiberJunctionWidth),
3671 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3672 i*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
3673 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
3674 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
3677 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
3678 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3679 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3680 (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
3681 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
3684 /////////////////////////////////////////////////////////////////////////////////
3685 TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
3686 ///////////////////////////////////////////////////////////////////
3687 // Main method generating Ladder Cable bundles containing n cables
3688 ///////////////////////////////////////////////////////////////////
3689 Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
3690 Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])};
3691 TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]),cableOrig);
3692 TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
3693 char laddercabletransname[100];
3694 for(Int_t i=0; i<n; i++){
3695 snprintf(laddercabletransname,100,"LadderCableTrans%i",i+1);
3696 laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
3697 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
3701 /////////////////////////////////////////////////////////////////////////////////
3702 TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
3703 /////////////////////////////////////////////////////////////
3704 // Method generating Ladder Cable List Assemblies
3705 // containing two cables bundles, i.e. P+N readout for one endcap
3706 /////////////////////////////////////////////////////////////
3707 const Int_t kladdercableassemblynumber = 2;
3708 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
3709 TGeoVolume* ladderCable[kladdercableassemblynumber];
3710 char laddercableassemblyname[100];
3711 TList* laddercableassemblylist = new TList();
3712 for(Int_t i=0; i<kladdercableassemblynumber; i++){
3713 snprintf(laddercableassemblyname,100,"LadderCableAssembly%i",i+1);
3714 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
3715 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
3716 new TGeoCombiTrans((n-1)
3717 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3718 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
3719 0.,new TGeoRotation("",180,0.,0.)));
3720 laddercableassemblylist->Add(ladderCable[i]);
3722 return laddercableassemblylist;
3724 ///////////////////////////////////////////////////////////////////////////////
3725 void AliITSv11GeometrySSD::SetLadderSegment(){
3726 /////////////////////////////////////////////////////////////
3727 // Method Generating Ladder Segment Array
3728 /////////////////////////////////////////////////////////////
3729 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
3730 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
3732 /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
3733 TGeoXtru *laddersegmentshape = new TGeoXtru(2);
3734 static const Int_t ntrianglevtx = 3;
3735 Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
3736 Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
3737 laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
3738 laddersegmentshape->DefineSection(0,0);
3739 laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth); // MVL
3740 fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
3741 fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
3744 if(!fCreateMaterials) CreateMaterials();
3745 if(!fTransformationMatrices) CreateTransformationMatrices();
3746 if(!fBasicObjects) CreateBasicObjects();
3747 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
3748 // Placing Carbon Fiber Support
3749 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
3750 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3751 fcarbonfibersupportmatrix[j]);
3752 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3753 fcarbonfibersupportmatrix[j]);
3755 // Placing Carbon Fiber Junction
3756 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
3757 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
3758 fcarbonfiberjunctionmatrix[j]);
3760 // Placing Carbon Fiber Lower Support
3761 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
3762 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
3763 fcarbonfiberlowersupportrans[j]);
3765 // Placing SSD Sensor Support
3766 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
3767 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
3768 fssdsensorsupport[1][i],
3769 j+1,fssdsensorsupportmatrix[j]);
3770 // Placing SSD Cooling Tube Support
3771 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
3772 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3773 fcoolingtubesupportmatrix[j]);
3774 // Placing SSD Cooling Tube
3775 fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
3776 fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
3777 // Placing SSD Hybrid
3780 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
3781 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3784 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
3785 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3788 // Placing Cooling Block System
3789 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
3791 for(Int_t j=0; j<fgkflexnumber; j++){
3792 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
3793 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
3797 ///////////////////////////////////////////////////////////////////////////////
3798 void AliITSv11GeometrySSD::SetEndLadderSegment(){
3799 /////////////////////////////////////////////////////////////
3800 // Method Generating End Ladder
3801 /////////////////////////////////////////////////////////////
3802 // End Ladder Carbon Fiber Junction
3803 /////////////////////////////////////////////////////////////
3804 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
3805 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
3806 if(!fCreateMaterials) CreateMaterials();
3807 if(!fTransformationMatrices) CreateTransformationMatrices();
3808 if(!fBasicObjects) CreateBasicObjects();
3809 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
3810 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
3811 fendladdersegment[i]->AddNode(j==2 ?
3812 fendladdercarbonfiberjunction[i][1] :
3813 fendladdercarbonfiberjunction[i][0],
3814 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
3816 /////////////////////////////////////////////////////////////
3817 // End Ladder Carbon Fiber Support
3818 /////////////////////////////////////////////////////////////
3819 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
3820 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
3821 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3822 fendladdercarbonfibermatrix[i][j]);
3823 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3824 fendladdercarbonfibermatrix[i][j]);
3826 /////////////////////////////////////////////////////////////
3827 // End Ladder Mounting Block
3828 /////////////////////////////////////////////////////////////
3829 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3830 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
3831 fendladdermountingblockcombitrans[i]);
3832 /////////////////////////////////////////////////////////////
3833 // End Ladder Mounting Block Clip
3834 /////////////////////////////////////////////////////////////
3835 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3836 for(Int_t j=0; j<2; j++)
3837 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
3838 fendladdermountingblockclipmatrix[i][j]);
3839 /////////////////////////////////////////////////////////////
3840 // End Ladder Lower Supports
3841 /////////////////////////////////////////////////////////////
3842 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
3843 fendladderlowersupptrans[0]);
3844 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
3845 fendladderlowersupptrans[1]);
3846 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
3847 fendladderlowersupptrans[2]);
3848 /////////////////////////////////////////////////////////////
3849 // End Ladder Cooling Tube Support
3850 /////////////////////////////////////////////////////////////
3851 for(Int_t i=0; i<2; i++)
3852 for(Int_t j=0; j<(i==0?4:2); j++)
3853 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3854 fendladdercoolingtubesupportmatrix[i][j]);
3855 /////////////////////////////////////////////////////////////
3856 // End Ladder Cooling Tube Support
3857 /////////////////////////////////////////////////////////////
3858 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
3859 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
3860 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
3861 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
3863 ///////////////////////////////////////////////////////////////////////////////
3864 void AliITSv11GeometrySSD::SetLadder(){
3865 /////////////////////////////////////////////////////////////
3866 // Method Generating Ladder of Layer 5 and 6
3867 /////////////////////////////////////////////////////////////
3868 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
3869 fgkSSDLay6SensorsNumber};
3870 /////////////////////////////////////////////////////////////////////////////
3871 /// Generating Ladder Mother Volume Containing Ladder
3872 /////////////////////////////////////////////////////////////////////////////
3873 TGeoXtru* laddershape[fgkladdernumber];
3874 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
3875 const Int_t kmothervertexnumber = 8;
3876 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
3877 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
3878 ///////////////////////
3879 // Setting the vertices
3880 ///////////////////////
3881 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
3882 * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]);
3883 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
3884 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
3885 xmothervertex[0][1] = xmothervertex[0][0];
3886 ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010
3887 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
3888 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
3889 ymothervertex[0][2] = ymothervertex[0][1];
3890 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
3891 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
3892 xmothervertex[0][4] = -xmothervertex[0][3];
3893 ymothervertex[0][4] = ymothervertex[0][3];
3894 xmothervertex[0][5] = -xmothervertex[0][2];
3895 ymothervertex[0][5] = ymothervertex[0][2];
3896 xmothervertex[0][6] = -xmothervertex[0][1];
3897 ymothervertex[0][6] = ymothervertex[0][1];
3898 xmothervertex[0][7] = -xmothervertex[0][0];
3899 ymothervertex[0][7] = ymothervertex[0][0];
3900 for(Int_t i=0; i<kmothervertexnumber; i++){
3901 xmothervertex[1][i] = xmothervertex[0][i];
3902 ymothervertex[1][i] = ymothervertex[0][i];
3904 ///////////////////////////////////////////////////////////////////////////
3905 // Disalignement Mother Volume corrections 25/08/08
3906 ///////////////////////////////////////////////////////////////////////////
3907 TGeoXtru* leftladdershape1[fgkladdernumber];
3908 TGeoXtru* leftladdershape2[fgkladdernumber];
3909 TGeoXtru* centersensorladdershape[fgkladdernumber];
3910 TGeoXtru* rightladdershape1[fgkladdernumber];
3911 TGeoXtru* rightladdershape2[fgkladdernumber];
3912 for(Int_t i=0; i<fgkladdernumber; i++){
3913 leftladdershape1[i] = new TGeoXtru(2);
3914 leftladdershape2[i] = new TGeoXtru(2);
3915 centersensorladdershape[i] = new TGeoXtru(2);
3916 rightladdershape1[i] = new TGeoXtru(2);
3917 rightladdershape2[i] = new TGeoXtru(2);
3919 //////////////////////////////////////
3920 // Setting the names for shapes
3921 //////////////////////////////////////
3922 leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
3923 leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
3924 leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
3925 leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
3926 centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
3927 centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
3928 rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
3929 rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
3930 rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
3931 rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
3932 //////////////////////////////////////
3933 Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
3934 Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
3935 Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
3936 Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
3937 Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
3938 Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
3939 for(Int_t i=0; i<fgkladdernumber; i++) {
3940 for(Int_t j=0; j<kmothervertexnumber; j++){
3941 xcentersensorvertex[i][j] = xmothervertex[i][j];
3942 ycentersensorvertex[i][j] = ymothervertex[i][j];
3943 xend1laddervertex[i][j] = xmothervertex[i][j];
3944 yend1laddervertex[i][j] = ymothervertex[i][j];
3945 xend2laddervertex[i][j] = xmothervertex[i][j];
3946 yend2laddervertex[i][j] = ymothervertex[i][j];
3948 // Add some space around sensors to accommodate misalignments
3949 xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
3950 xcentersensorvertex[i][1] = xcentersensorvertex[0][0];
3951 xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
3952 xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
3954 ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
3955 ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
3957 // Center Ladder Piece
3958 centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
3959 ycentersensorvertex[i]);
3960 centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3961 + 1.45*fgkSSDMountingBlockWidth);
3962 centersensorladdershape[i]->DefineSection(1, ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
3963 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
3964 - 2.4*fgkSSDMountingBlockWidth);
3966 // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
3968 // Cuts off first corner (neg x)
3969 xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
3970 xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
3971 // Cuts off last part (pos x)
3972 xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
3973 xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
3975 leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3976 yend1laddervertex[i]);
3977 leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
3978 leftladdershape1[i]->DefineSection(1, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3979 - fgkEndLadderMountingBlockPosition[0]);
3981 leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3982 yend2laddervertex[i]);
3983 leftladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3984 - fgkEndLadderMountingBlockPosition[0]);
3985 leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
3986 + 1.45*fgkSSDMountingBlockWidth); // connect to main volume at -1.6725 cm
3988 rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3989 yend1laddervertex[i]);
3990 rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
3991 +fgkEndLadderCarbonFiberLowerJunctionLength[0]
3992 -2.4*fgkSSDMountingBlockWidth);
3993 rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
3994 + fgkEndLadderMountingBlockPosition[1]);
3996 rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3997 yend2laddervertex[i]);
3998 rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
3999 + fgkEndLadderMountingBlockPosition[1]);
4000 rightladdershape2[i]->DefineSection(1, ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4001 + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4003 TGeoCompositeShape* laddershapecontainer[2];
4004 laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4005 "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4006 "+Lay5CenterSensorContainer"
4007 "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4008 laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4009 "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4010 "+Lay6CenterSensorContainer"
4011 "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4012 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4013 for(Int_t i=0; i<fgkladdernumber; i++){
4014 fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4015 fladder[i]->SetLineColor(4);
4017 ///////////////////////////////////////////////////////////////////////////
4018 if(!fCreateMaterials) CreateMaterials();
4019 if(!fTransformationMatrices) CreateTransformationMatrices();
4020 if(!fBasicObjects) CreateBasicObjects();
4022 SetEndLadderSegment();
4023 for(Int_t i=0; i<fgkladdernumber; i++){
4024 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4025 //////////////////////////
4026 /// Placing Ladder Segment
4027 //////////////////////////
4028 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4029 fladdersegment[i==0 ? 1 : 0],
4030 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4031 //////////////////////////
4032 /// Placing SSD Sensor
4033 //////////////////////////
4034 if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
4035 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4036 fssdsensormatrix[i][j]);
4038 ///////////////////////////////
4039 /// Placing End Ladder Segment
4040 ///////////////////////////////
4041 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4042 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4044 /////////////////////////////////////////////////////////////////////////////
4045 /// Placing Ladder Cables
4046 /////////////////////////////////////////////////////////////////////////////
4047 Int_t sidecablenumber[2][2];
4048 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4049 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4050 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4051 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4052 Double_t carbonfibertomoduleposition[3];
4053 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4054 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4055 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4056 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4057 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4058 - fgkSSDSensorCenterSupportThickness[0]);
4059 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4060 + 0.5*fgkCoolingTubeSupportHeight
4061 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4062 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
4063 Double_t ssdendladdercablelength[4];
4064 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
4065 + fgkSSDSensorLength
4066 - fgkSSDModuleStiffenerPosition[1]
4067 - fgkSSDStiffenerWidth
4068 - fgkSSDFlexWidth[0]
4069 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4070 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
4071 + fgkSSDModuleStiffenerPosition[1]
4072 + fgkSSDStiffenerWidth
4073 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4074 ssdendladdercablelength[2] = ssdendladdercablelength[1]
4075 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
4076 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4077 - kendladdercablecorrection;
4078 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4079 + carbonfibertomoduleposition[1]
4080 - fgkSSDModuleStiffenerPosition[1]
4081 - fgkSSDStiffenerWidth)
4082 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
4084 TList* laddercableassemblylist[4];
4085 const Int_t kendladdercablesnumber = 4;
4086 TGeoRotation *laddercablerot = new TGeoRotation();
4087 laddercablerot->SetAngles(90.,60.,-90.);
4088 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4089 for(Int_t j=0; j<kendladdercablesnumber; j++){
4090 laddercableassemblylist[j] =
4091 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4092 ssdendladdercablelength[j]);
4093 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4094 j<2?1:2,fladdercablematrix[i][j]);
4097 ////////////////////////////////////////////////////////////////////////////////
4098 void AliITSv11GeometrySSD::SetLayer(){
4099 ////////////////////////////////////////////////////////////////////////////////
4100 // Creating Ladder of Layer 5 and Layer 6
4101 /////////////////////////////////////////////////////////////
4102 if(!fCreateMaterials) CreateMaterials();
4103 if(!fTransformationMatrices) CreateTransformationMatrices();
4104 if(!fBasicObjects) CreateBasicObjects();
4105 SetLadder(); // Generating the ladder of Layer5 and Layer6
4106 const Int_t kssdlayladdernumber[fgklayernumber] =
4107 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4108 /////////////////////////////////////////////////////////////
4109 // Generating mother volumes for Layer5 and Layer6
4110 /////////////////////////////////////////////////////////////
4111 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4112 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
4113 Int_t *ladderindex[fgklayernumber];
4114 Int_t index[fgklayernumber] = {8,9};
4115 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4116 for(Int_t i=0; i<fgklayernumber; i++)
4117 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4118 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4119 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4120 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4121 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4123 /////////////////////////////////////////////////////////////
4124 // Deallocating memory
4125 /////////////////////////////////////////////////////////////
4126 for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
4128 ////////////////////////////////////////////////////////////////////////////////
4129 void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
4130 /////////////////////////////////////////////////////////////
4131 // Insert the layer 5 in the mother volume.
4132 /////////////////////////////////////////////////////////////
4134 AliError("Can't insert layer5, mother is null!\n");
4137 if(!fSSDLayer5) SetLayer();
4139 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4140 + fgkLay5CenterITSPosition);
4141 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
4143 ////////////////////////////////////////////////////////////////////////////////
4144 void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
4145 /////////////////////////////////////////////////////////////
4146 // Insert the layer 6 in the mother volume.
4147 /////////////////////////////////////////////////////////////
4149 AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4152 if(!fSSDLayer6) SetLayer();
4154 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4155 + fgkLay6CenterITSPosition);
4156 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
4158 ////////////////////////////////////////////////////////////////////////////////
4159 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4160 /////////////////////////////////////////////////////////////
4161 // Method generating the Arc structure of Ladder Support
4162 /////////////////////////////////////////////////////////////
4163 const Int_t kssdlayladdernumber[fgklayernumber] =
4164 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4165 Double_t mountingsupportedge[fgklayernumber];
4166 Double_t mountingblockratio[fgklayernumber];
4167 Double_t theta[fgklayernumber];
4168 Double_t phi[fgklayernumber];
4169 Double_t psi0[fgklayernumber];
4170 Double_t deltapsi[fgklayernumber];
4171 TVector3* mountingsupportedgevector[fgklayernumber];
4172 for(Int_t i=0; i<fgklayernumber; i++){
4173 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4174 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4175 * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
4176 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4177 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4178 / kssdlayladdernumber[i])));
4179 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4180 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4181 mountingsupportedgevector[i] = new TVector3();
4182 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4183 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4184 (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4185 (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
4186 psi0[i] = 0.5*TMath::Pi()-phi[i];
4187 deltapsi[i] = (theta[i]+phi[i])/nedges;
4189 TVector3** vertex[fgklayernumber];
4190 TList* vertexlist[fgklayernumber];
4191 Int_t indexedge[fgklayernumber] = {0,0};
4192 for(Int_t i=0; i<fgklayernumber; i++){
4193 vertex[i] = new TVector3*[nedges+1];
4194 vertexlist[i] = new TList();
4196 for(Int_t i=0; i<fgklayernumber; i++){
4197 for(Int_t j=0; j<nedges+1; j++){
4198 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4199 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]), 0);
4200 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4201 vertexlist[i]->Add(vertex[i][j]);
4203 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4205 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4206 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4207 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4208 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4209 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4210 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4211 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4212 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4213 for(Int_t i=0; i<fgklayernumber; i++){
4214 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4215 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4216 xcentervertex[i] = new Double_t[indexedge[i]+3];
4217 ycentervertex[i] = new Double_t[indexedge[i]+3];
4218 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4219 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4220 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4221 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4222 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4223 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4224 ((TVector3*)vertexlist[i]->At(j))->X();
4225 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4226 ((TVector3*)vertexlist[i]->At(j))->Y();
4227 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4228 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4229 if(j<indexedge[i]+1){
4230 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4231 ((TVector3*)vertexlist[i]->At(j))->X();
4232 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4233 ((TVector3*)vertexlist[i]->At(j))->Y();
4234 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4235 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4238 xsidevertex[i][1] = xsidevertex[i][0];
4239 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4240 xsidevertex[i][2] = xsidevertex[i][3];
4241 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4242 xcentervertex[i][1] = xcentervertex[i][0];
4243 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4244 xcentervertex[i][2] = xcentervertex[i][3];
4245 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4246 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4247 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4248 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4249 ycenterlowervertex[i][0] = ysidevertex[i][0];
4250 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4251 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4253 /////////////////////////////////////////////////////////////
4254 // Building the Arc Structure of Ladder Supports
4255 /////////////////////////////////////////////////////////////
4256 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4257 TGeoXtru* centermountingsupportshape[fgklayernumber];
4258 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4259 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4260 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4261 TGeoVolume* centermountingblocksupport[fgklayernumber];
4262 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4263 TGeoVolume* centerladdersupportpiece[fgklayernumber];
4264 char sidemountingblockname[100];
4265 char centermountingblockname[100];
4266 char sideladdersupportpiecename[100];
4267 char centerladdersupportpiecename[100];
4268 for(Int_t i=0; i<fgklayernumber; i++){
4269 snprintf(sidemountingblockname,100,"MountingBlockSupportSideLay%dArc",i+5);
4270 snprintf(centermountingblockname,100,"MountingBlockSupportCenterLay%dArc",i+5);
4271 snprintf(sideladdersupportpiecename,100,"SideLadderSupportPieceLay%d",i+5);
4272 snprintf(centerladdersupportpiecename,100,"CenterLadderSupportPieceLay%d",i+5);
4273 sidemountingblocksupportshape[i] = new TGeoXtru(2);
4274 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4275 xsidevertex[i],ysidevertex[i]);
4276 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4277 -fgkMountingBlockSupportWidth[0]);
4278 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4279 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4280 sidemountingblocksupportshape[i],
4281 fSSDAlCoolBlockMedium);
4282 sidemountingblocksupport[i]->SetLineColor(9);
4283 centermountingsupportshape[i] = new TGeoXtru(2);
4284 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4285 xcentervertex[i],ycentervertex[i]);
4286 centermountingsupportshape[i]->DefineSection(0,0.);
4287 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4288 -fgkMountingBlockSupportWidth[0]);
4290 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4291 centermountingsupportshape[i],
4292 fSSDAlCoolBlockMedium);
4293 centermountingblocksupport[i]->SetLineColor(9);
4294 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4295 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4296 xsidelowervertex[i],ysidelowervertex[i]);
4297 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4298 -fgkMountingBlockSupportWidth[0]);
4299 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4300 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4301 sideladdersupportpieceshape[i],
4302 fSSDCarbonFiberMedium);
4303 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4304 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4305 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4306 xcenterlowervertex[i],ycenterlowervertex[i]);
4307 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4308 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4309 -fgkMountingBlockSupportWidth[0]);
4310 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4311 centerladdersupportpieceshape[i],
4312 fSSDCarbonFiberMedium);
4313 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4315 /////////////////////////////////////////////////////////////
4316 // Building the Up Structure of Ladder Supports
4317 /////////////////////////////////////////////////////////////
4318 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4319 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4320 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4321 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4322 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4323 //////////////////////////////////////////////////////////
4324 // Setting the volume for TGeoXtru Mounting Block Piece
4325 //////////////////////////////////////////////////////////
4326 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4327 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4328 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4329 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4330 TGeoVolume* mountingblockpieceup[fgklayernumber];
4331 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4332 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4333 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4334 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
4335 char mountingblockpiecedownname[100];
4336 char mountingblockpieceupname[100];
4337 for(Int_t i=0; i<fgklayernumber; i++){
4338 ///////////////////////////
4339 // Mounting Block Down Vertex
4340 ///////////////////////////
4341 mountingblockpiecedownshape[i] = new TGeoXtru(2);
4342 snprintf(mountingblockpiecedownname,100,"MountingBlockPieceDownLay%d",i+5);
4343 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4344 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4345 + fgkMountingBlockSupportDownHeight
4346 - fgkSSDLadderVerticalDisalignment;
4347 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4348 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4349 + fgkSSDMountingBlockHeight[1]
4350 - 0.5*fgkCoolingTubeSupportHeight
4351 - fgkSSDModuleCoolingBlockToSensor;
4352 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4353 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4354 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4355 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4356 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4357 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4358 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4359 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4360 + fgkSSDMountingBlockHeight[2]
4361 - fgkSSDMountingBlockHeight[0];
4362 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4363 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4364 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4365 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4366 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4367 mountingblockpiecedownyvertex[i]);
4368 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4369 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4370 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
4371 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
4372 mountingblockpiecedown[i]->SetLineColor(fColorG10);
4374 ///////////////////////////
4375 // Mounting Block Up Vertex
4376 ///////////////////////////
4377 mountingblockpieceupshape[i] = new TGeoXtru(2);
4378 snprintf(mountingblockpieceupname,100,"MountingBlockPieceUpLay%d",i+5);
4379 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4380 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4381 + fgkMountingBlockSupportUpHeight[i]
4382 - fgkSSDLadderVerticalDisalignment;
4383 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4384 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4385 + fgkSSDMountingBlockHeight[1]
4386 - 0.5*fgkCoolingTubeSupportHeight
4387 - fgkSSDModuleCoolingBlockToSensor;
4388 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4389 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4390 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4391 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4392 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4393 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4394 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4395 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4396 + fgkSSDMountingBlockHeight[2]
4397 - fgkSSDMountingBlockHeight[0];
4398 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4399 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4400 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4401 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4403 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4404 mountingblockpieceupyvertex[i]);
4405 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4406 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4407 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
4408 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
4409 mountingblockpieceup[i]->SetLineColor(fColorG10);
4411 ///////////////////////////////////////////////////////////////////
4412 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4413 ///////////////////////////////////////////////////////////////////
4414 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4415 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4416 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4417 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4418 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4419 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4420 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4421 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4422 char mountingblocksupportrapezoidowname[100];
4423 char mountingblocksupportrapezoidupname[100];
4424 Double_t scalefactor = 3./4.;
4425 for(Int_t i=0; i<fgklayernumber; i++){
4426 ////////////////////////////////////////////
4427 // Mounting Block Support Down Trapezoid Vertex
4428 ////////////////////////////////////////////
4429 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4430 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4431 - mountingsupportedge[i];
4432 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4433 mountingblocksupportrapezoidownxvertex[i][1] =
4434 mountingblocksupportrapezoidownxvertex[i][0];
4435 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4436 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4437 - mountingblockpiecedownyvertex[i][0]);
4438 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4439 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4440 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4441 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4442 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4443 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4445 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4446 mountingblocksupportrapezoidownyvertex[i]);
4447 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4448 -fgkMountingBlockSupportWidth[0]);
4449 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4450 snprintf(mountingblocksupportrapezoidowname,100,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4451 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
4452 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
4453 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4454 ////////////////////////////////////////////
4455 // Mounting Block Support Up Trapezoid Vertex
4456 ////////////////////////////////////////////
4457 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4458 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4459 - mountingsupportedge[i];
4460 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4461 mountingblocksupportrapezoidupxvertex[i][1] =
4462 mountingblocksupportrapezoidupxvertex[i][0];
4463 mountingblocksupportrapezoidupyvertex[i][1] =
4464 mountingblockpieceupyvertex[i][0]
4465 + scalefactor*(mountingblockpieceupyvertex[i][1]
4466 - mountingblockpieceupyvertex[i][0]);
4467 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4468 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4469 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4470 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4471 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4472 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4474 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4475 mountingblocksupportrapezoidupyvertex[i]);
4476 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4477 -fgkMountingBlockSupportWidth[0]);
4478 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4479 snprintf(mountingblocksupportrapezoidupname,100,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4480 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
4481 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
4482 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4484 ///////////////////////////////////////////////////////////////////
4485 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4486 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4487 Double_t boxoriginup[fgklayernumber][2][3];
4488 Double_t boxorigindown[fgklayernumber][2][3];
4489 char mountingblocksupportboxdownname[100];
4490 char mountingblocksupportboxupname[100];
4491 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4492 mountingblocksupportrot->SetAngles(90.,180.,-90);
4493 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4494 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4495 TGeoHMatrix* laddersupportmatrix[2];
4496 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4497 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4498 /////////////////////////////////////////////////////////////
4499 // Creating Mother Volume for Containment
4500 /////////////////////////////////////////////////////////////
4501 Double_t *xmothervertex[fgklayernumber];
4502 Double_t *ymothervertex[fgklayernumber];
4503 for(Int_t i=0; i<fgklayernumber; i++){
4504 xmothervertex[i] = new Double_t[8];
4505 ymothervertex[i] = new Double_t[8];
4507 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4508 TGeoVolume* downmotherladdersupport[fgklayernumber];
4509 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4510 TGeoVolume* upmotherladdersupport[fgklayernumber];
4511 char upmotheladdersupportname[100];
4512 char downmotheladdersupportname[100];
4513 for(Int_t i=0; i<fgklayernumber; i++){
4514 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4515 - mountingsupportedge[i];
4516 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4517 xmothervertex[i][1] = xmothervertex[i][0];
4518 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4519 + fgkMountingBlockSupportWidth[0];
4520 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4521 ymothervertex[i][2] = ymothervertex[i][1];
4522 xmothervertex[i][3] = xmothervertex[i][2];
4523 ymothervertex[i][3] = -ymothervertex[i][0];
4524 xmothervertex[i][4] = -xmothervertex[i][0];
4525 ymothervertex[i][4] = ymothervertex[i][3];
4526 xmothervertex[i][5] = xmothervertex[i][4];
4527 ymothervertex[i][5] = -ymothervertex[i][1];
4528 xmothervertex[i][6] = -xmothervertex[i][2];
4529 ymothervertex[i][6] = ymothervertex[i][5];
4530 xmothervertex[i][7] = xmothervertex[i][6];
4531 ymothervertex[i][7] = ymothervertex[i][0];
4533 snprintf(downmotheladdersupportname,100,"LadderSupportDownLay%d",i+5);
4534 snprintf(upmotheladdersupportname,100,"LadderSupportUpLay%d",i+5);
4536 downmotherladdersupportshape[i] = new TGeoXtru(2);
4537 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4538 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4539 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4540 + fgkMountingBlockSupportDownHeight
4541 + fgkSSDMountingBlockHeight[1]
4542 - 0.5*fgkCoolingTubeSupportHeight
4543 - fgkSSDModuleCoolingBlockToSensor
4544 - fgkSSDLadderVerticalDisalignment);
4546 // - fgkSSDModuleVerticalDisalignment);
4547 //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4549 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4550 downmotherladdersupportshape[i],fSSDAir);
4551 upmotherladdersupportshape[i] = new TGeoXtru(2);
4552 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4553 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4554 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4555 + fgkMountingBlockSupportUpHeight[i]
4556 + fgkSSDMountingBlockHeight[1]
4557 - 0.5*fgkCoolingTubeSupportHeight
4558 - fgkSSDModuleCoolingBlockToSensor
4559 - fgkSSDLadderVerticalDisalignment);
4561 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4562 upmotherladdersupportshape[i],fSSDAir);
4564 for(Int_t i=0; i<fgklayernumber; i++){
4565 /////////////////////////
4566 // Setting the box origin
4567 /////////////////////////
4568 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4569 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
4570 + 0.5*fgkMountingBlockSupportDownHeight
4571 - 0.5*fgkSSDLadderVerticalDisalignment;
4572 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4573 - 0.5*fgkMountingBlockSupportWidth[0];
4575 boxorigindown[i][1][0] = 0.0;
4576 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4577 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4578 - fgkMountingBlockSupportWidth[0]);
4580 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4581 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4582 + 0.5*fgkMountingBlockSupportUpHeight[i]
4583 - 0.5*fgkSSDLadderVerticalDisalignment;
4584 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4585 - 0.5*fgkMountingBlockSupportWidth[0];
4587 boxoriginup[i][1][0] = 0.0;
4588 boxoriginup[i][1][1] = boxoriginup[i][0][1];
4589 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4590 - fgkMountingBlockSupportWidth[0]);
4592 /////////////////////////
4593 // Setting the boxes
4594 /////////////////////////
4595 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4596 + fgkSSDMountingBlockLength[0]),
4597 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
4598 0.5*fgkMountingBlockSupportWidth[0],
4599 boxorigindown[i][0]);
4600 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4601 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
4602 0.5*(fgkMountingBlockSupportWidth[1]
4603 - fgkMountingBlockSupportWidth[0]),
4604 boxorigindown[i][1]);
4606 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4607 + fgkSSDMountingBlockLength[0]),
4608 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
4609 0.5*fgkMountingBlockSupportWidth[0],
4612 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4613 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
4614 0.5*(fgkMountingBlockSupportWidth[1]
4615 - fgkMountingBlockSupportWidth[0]),
4617 ///////////////////////////////////////
4618 // Adding the Volumes to Mother Volume
4619 ///////////////////////////////////////
4620 for(Int_t j=0; j<2; j++){
4621 snprintf(mountingblocksupportboxdownname,100,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4622 snprintf(mountingblocksupportboxupname,100,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4623 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4624 mountingblocksupportboxdownshape[i][j],
4625 fSSDCarbonFiberMedium);
4626 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4627 mountingblocksupportboxupshape[i][j],
4628 fSSDCarbonFiberMedium);
4629 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4630 mountingblocksupportboxup[i][j]->SetLineColor(9);
4631 for(Int_t k=0; k<2; k++){
4632 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4633 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4636 for(Int_t k=0; k<2; k++){
4637 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4638 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4639 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4640 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4641 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4642 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4643 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4644 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4645 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4646 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4647 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4648 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
4651 TList* laddersupportlist = new TList();
4652 laddersupportlist->Add(downmotherladdersupport[0]);
4653 laddersupportlist->Add(upmotherladdersupport[0]);
4654 laddersupportlist->Add(downmotherladdersupport[1]);
4655 laddersupportlist->Add(upmotherladdersupport[1]);
4656 /////////////////////////////////////////////////////////////
4657 // Deallocating memory
4658 /////////////////////////////////////////////////////////////
4659 for(Int_t i=0; i<fgklayernumber; i++){
4660 for(Int_t j=0; j<nedges+1; j++)
4661 delete vertex[i][j];
4662 delete mountingsupportedgevector[i];
4663 delete [] vertex[i];
4664 delete vertexlist[i];
4665 delete [] xsidevertex[i];
4666 delete [] ysidevertex[i];
4667 delete [] xcentervertex[i];
4668 delete [] ycentervertex[i];
4669 delete [] xsidelowervertex[i];
4670 delete [] ysidelowervertex[i];
4671 delete [] xcenterlowervertex[i];
4672 delete [] ycenterlowervertex[i];
4673 delete [] xmothervertex[i];
4674 delete [] ymothervertex[i];
4676 delete [] xsidevertex;
4677 delete [] ysidevertex;
4678 delete [] xcentervertex;
4679 delete [] ycentervertex;
4680 delete [] xsidelowervertex;
4681 delete [] ysidelowervertex;
4682 delete [] xcenterlowervertex;
4683 delete [] ycenterlowervertex;
4684 delete globalrefladdersupportrot;
4685 delete mountingblocksupportrot;
4686 /////////////////////
4687 return laddersupportlist;
4689 ////////////////////////////////////////////////////////////////////////////////
4690 void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4691 //////////////////////////////////////////
4692 // Method Generating Ladder Support Ring
4693 //////////////////////////////////////////
4694 if(!fCreateMaterials) CreateMaterials();
4695 if(!fTransformationMatrices) CreateTransformationMatrices();
4696 if(!fBasicObjects) CreateBasicObjects();
4697 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4698 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4699 const Int_t kssdlayladdernumber[fgklayernumber] =
4700 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4701 Double_t mountingsupportedge[fgklayernumber];
4702 Double_t mountingblockratio[fgklayernumber];
4703 Double_t theta[fgklayernumber];
4704 Double_t phi[fgklayernumber];
4705 for(Int_t i=0; i<fgklayernumber; i++){
4706 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4707 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4708 *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
4709 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4710 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4711 / kssdlayladdernumber[i])));
4712 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4713 / fgkMountingBlockSupportRadius[i]);
4714 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4716 TGeoRotation* globalrot = new TGeoRotation();
4717 globalrot->SetAngles(0.,-90.,0.);
4718 TGeoRotation** laddersupportrot[fgklayernumber];
4719 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4720 for(Int_t i=0; i<fgklayernumber; i++){
4721 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4722 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4723 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4724 laddersupportrot[i][j] = new TGeoRotation();
4725 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4727 case 0: //Ladder of Layer5
4728 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4729 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4730 laddersupportmatrix[i][j]);
4732 case 1: //Ladder of Layer6
4733 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4734 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4735 laddersupportmatrix[i][j]);
4740 /////////////////////////////////////////////////////////////
4741 // Creating Lower Ladder Support
4742 /////////////////////////////////////////////////////////////
4743 TVector3** ringsupportvertex[fgklayernumber];
4744 Double_t angle = 360./nedges;
4745 for(Int_t i=0; i<fgklayernumber; i++){
4746 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4747 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4748 * TMath::Cos(theta[i]), 0);
4749 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4750 - mountingsupportedge[i],
4751 ringsupportvertex[i][0]->Y(), 0);
4752 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4753 ringsupportvertex[i][1]->Y(),0);
4754 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4755 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4756 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4757 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4758 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4759 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4761 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4762 for(Int_t j=0; j<nedges+1; j++){
4763 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
4764 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
4765 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle), 0);
4768 Double_t **xmothervertex = new Double_t*[fgklayernumber];
4769 Double_t **ymothervertex = new Double_t*[fgklayernumber];
4770 for(Int_t i=0; i<fgklayernumber; i++){
4771 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4772 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4773 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4774 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4775 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4778 ////////////////////////////////////////////////////////////////////////////////
4779 // Start Corrections 13/06/08
4780 ////////////////////////////////////////////////////////////////////////////////
4781 char lowerladderpconsupportname[100];
4782 TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4783 TGeoVolume* lowerladderpconsupport[fgklayernumber];
4784 Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4785 Double_t lowerladderpconradiusmax[fgklayernumber];
4786 Double_t lowerladderpconradiusmin[fgklayernumber];
4787 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4788 lowerladdersupportrot->SetAngles(90.,180.,-90);
4789 for(Int_t i=0; i<fgklayernumber; i++){
4790 lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4791 * TMath::Cos(theta[i]);
4792 lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
4794 for(Int_t i=0; i<fgklayernumber; i++){
4795 /////////////////////////// Modified Version ?///////////////////
4796 lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4797 for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
4798 lowerladderpconezsection[j],lowerladderpconradiusmin[i],
4799 lowerladderpconradiusmax[i]);
4800 snprintf(lowerladderpconsupportname,100,"LowerLadderPConSupportNameLay%d",i+5);
4801 lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
4802 lowerladderpconsupport[i]->SetLineColor(fColorAl);
4803 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
4804 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
4806 ////////////////////////////////////////////////////////////////////////////////
4807 // End Corrections 13/06/08
4808 ////////////////////////////////////////////////////////////////////////////////
4809 /*char lowerladdersupportname[30];
4810 TGeoXtru* lowerladdersupportshape[fgklayernumber];
4811 TGeoVolume* lowerladdersupport[fgklayernumber];
4812 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4813 lowerladdersupportrot->SetAngles(90.,180.,-90);
4814 for(Int_t i=0; i<fgklayernumber; i++){
4815 lowerladdersupportshape[i] = new TGeoXtru(2);
4816 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
4817 xmothervertex[i],ymothervertex[i]);
4818 lowerladdersupportshape[i]->DefineSection(0,0.);
4819 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4820 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
4821 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
4822 lowerladdersupportshape[i],fSSDSupportRingAl);
4823 lowerladdersupport[i]->SetLineColor(fColorAl);
4824 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
4825 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
4827 /////////////////////////////////////////////////////////////
4828 // Deallocating memory
4829 /////////////////////////////////////////////////////////////
4830 for(Int_t i=0; i<fgklayernumber; i++){
4831 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
4832 delete ringsupportvertex[i][j];
4833 delete [] ringsupportvertex[i];
4835 for(Int_t i=0; i<fgklayernumber; i++){
4836 delete [] xmothervertex[i];
4837 delete [] ymothervertex[i];
4839 delete [] xmothervertex;
4840 delete [] ymothervertex;
4842 for(Int_t i=0; i<fgklayernumber; i++){
4843 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
4844 delete laddersupportrot[i][j];
4845 delete [] laddersupportrot[i];
4848 ////////////////////////////////////////////////////////////////////////////////
4849 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
4850 /////////////////////////////////////////////////////////////
4851 // Method generating Endcap CoverPlate
4852 /////////////////////////////////////////////////////////////
4855 Int_t nendcapcoverplateholedges = 30;
4856 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
4857 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
4858 0.5*fgkEndCapCoverPlateThickness};
4859 TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
4860 nendcapcoverplateholedges,holesection);
4861 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
4862 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
4863 endcapcoverplatesmallhole->SetLineColor(6);
4864 TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
4865 nendcapcoverplateholedges,holesection);
4866 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
4867 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
4868 endcapcoverplatebighole->SetLineColor(6);
4869 //////////////////////////
4870 // Screw Piece Definition
4871 //////////////////////////
4872 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
4873 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
4874 CosD(0.5*smallscrewangle),
4875 0.5*fgkEndCapCoverPlateThickness);
4876 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
4877 endcapsmallscrewpieceshape,
4878 fSSDCoolingTubePhynox);
4879 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
4883 TGeoBBox* endcapcoverplateboxshape[4];
4884 TGeoVolume* endcapcoverplatebox[4];
4885 Double_t boxorigin[5][3];
4886 boxorigin[0][0] = 0.;
4887 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
4888 boxorigin[0][2] = 0.;
4890 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
4891 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
4892 boxorigin[1][2] = 0.;
4894 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
4895 + fgkEndCapCoverPlateSmallHoleSeparation[1];
4896 boxorigin[2][1] = boxorigin[1][1];
4897 boxorigin[2][2] = 0.;
4899 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
4900 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
4901 boxorigin[3][1] = boxorigin[1][1];
4902 boxorigin[3][2] = 0.;
4904 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4905 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
4906 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
4907 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
4909 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4910 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4911 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4912 + fgkEndCapCoverPlateSmallHoleRadius,
4913 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
4915 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4916 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4917 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4918 + fgkEndCapCoverPlateSmallHoleRadius,
4919 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
4921 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
4922 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4923 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4924 + fgkEndCapCoverPlateSmallHoleRadius,
4925 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
4927 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
4928 fSSDAlCoolBlockMedium);
4929 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
4930 fSSDAlCoolBlockMedium);
4931 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
4932 fSSDAlCoolBlockMedium);
4933 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
4934 fSSDAlCoolBlockMedium);
4935 endcapcoverplatebox[0]->SetLineColor(6);
4936 endcapcoverplatebox[1]->SetLineColor(6);
4937 endcapcoverplatebox[2]->SetLineColor(6);
4938 endcapcoverplatebox[3]->SetLineColor(6);
4939 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
4940 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4941 fgkEndCapCoverPlateSmallHoleRadius,
4942 0.5*fgkEndCapCoverPlateThickness,
4943 endcapfillingboxorigin);
4944 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
4945 fSSDAlCoolBlockMedium);
4946 endcapfillingbox->SetLineColor(6);
4947 ////////////////////////////
4948 // Contour shape Definition
4949 ////////////////////////////
4950 const Int_t kcontourvertexnumber = 10;
4951 Double_t xcontourvertex[kcontourvertexnumber];
4952 Double_t ycontourvertex[kcontourvertexnumber];
4953 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
4954 xcontourvertex[1] = xcontourvertex[0];
4955 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4956 xcontourvertex[3] = xcontourvertex[2];
4957 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
4958 xcontourvertex[5] = xcontourvertex[4];
4959 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4960 xcontourvertex[7] = xcontourvertex[6];
4961 xcontourvertex[8] = xcontourvertex[4];
4962 xcontourvertex[9] = xcontourvertex[8];
4963 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4964 - (kendcapcoverplatesmallholenumber[1]-1)
4965 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4966 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
4967 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4968 ycontourvertex[2] = ycontourvertex[1];
4969 ycontourvertex[3] = ycontourvertex[0];
4970 ycontourvertex[4] = ycontourvertex[3];
4971 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
4972 ycontourvertex[6] = ycontourvertex[5];
4973 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
4974 * fgkEndCapCoverPlateSmallHoleSeparation[2]
4975 + fgkEndCapCoverPlateSmallHoleRadius;
4976 ycontourvertex[8] = ycontourvertex[7];
4977 ycontourvertex[9] = ycontourvertex[0];
4979 Double_t xboxin, dxboxin, yboxin, dyboxin;
4980 Double_t xboxout, dxboxout, yboxout, dyboxout;
4981 Double_t coordmin, coordmax;
4982 coordmin = -fgkEndCapCoverPlateLength[0];
4983 coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4984 xboxout = 0.5*(coordmin+coordmax);
4985 dxboxout = 0.5*(coordmax-coordmin);
4986 coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4987 - (kendcapcoverplatesmallholenumber[1]-1)
4988 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4989 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
4990 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4991 yboxout = 0.5*(coordmin+coordmax);
4992 dyboxout = 0.5*(coordmax-coordmin);
4993 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
4994 coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4995 xboxin = 0.5*(coordmin+coordmax);
4996 dxboxin = 0.5*(coordmax-coordmin);
4997 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
4998 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
4999 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5000 + fgkEndCapCoverPlateSmallHoleRadius;
5001 yboxin = 0.5*(coordmin+coordmax);
5002 dyboxin = 0.5*(coordmax-coordmin);
5003 new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5004 TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5005 xboxout, yboxout, 0.);
5006 trendCapCoverPlateContourboxout->RegisterYourself();
5007 new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5008 TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5009 xboxin, yboxin, 0.);
5010 trendCapCoverPlateContourboxin->RegisterYourself();
5011 TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5012 "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5014 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5015 fSSDAlCoolBlockMedium);
5016 contour->SetLineColor(6);
5017 /////////////////////////////
5018 // Hole Contour Shape Definition
5019 ////////////////////////////
5020 coordmin = xcontourvertex[0];
5021 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5022 xboxout = 0.5*(coordmin+coordmax);
5023 dxboxout = 0.5*(coordmax-coordmin);
5024 coordmin = ycontourvertex[1];
5025 coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5026 yboxout = 0.5*(coordmin+coordmax);
5027 dyboxout = 0.5*(coordmax-coordmin);
5028 coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5029 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5030 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5031 xboxin = 0.5*(coordmin+coordmax);
5032 dxboxin = 0.5*(coordmax-coordmin);
5033 coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5034 - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5035 coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5036 yboxin = 0.5*(coordmin+coordmax);
5037 dyboxin = 0.5*(coordmax-coordmin);
5038 new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5039 TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5040 xboxout, yboxout, 0.);
5041 trendCapCoverPlateContourboxout1->RegisterYourself();
5042 new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5043 TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5044 xboxin, yboxin, 0.);
5045 trendCapCoverPlateContourboxin1->RegisterYourself();
5046 TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5047 "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5050 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5051 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5052 xboxout = 0.5*(coordmin+coordmax);
5053 dxboxout = 0.5*(coordmax-coordmin);
5054 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5055 - fgkEndCapCoverPlateWidth[0]);
5056 coordmax = ycontourvertex[0];
5057 yboxout = 0.5*(coordmin+coordmax);
5058 dyboxout = 0.5*(coordmax-coordmin);
5059 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5060 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5061 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5062 xboxin = 0.5*(coordmin+coordmax);
5063 dxboxin = 0.5*(coordmax-coordmin);
5064 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5065 - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5066 - fgkEndCapCoverPlateWidth[0]
5067 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5068 coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5069 yboxin = 0.5*(coordmin+coordmax);
5070 dyboxin = 0.5*(coordmax-coordmin);
5071 new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5072 TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5073 xboxout, yboxout, 0.);
5074 trendCapCoverPlateContourboxout2->RegisterYourself();
5075 new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5076 TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5077 xboxin, yboxin, 0.);
5078 trendCapCoverPlateContourboxin2->RegisterYourself();
5079 TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5080 "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5082 // const Int_t kholecontourvertexnumber = 10;
5084 Double_t xholecontourvertex[2][kcontourvertexnumber];
5085 Double_t yholecontourvertex[2][kcontourvertexnumber];
5086 xholecontourvertex[0][0] = xcontourvertex[0];
5087 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5088 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5089 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5090 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5091 + 0.5*(fgkEndCapCoverPlateLength[2]
5092 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5093 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5094 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5095 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5096 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5097 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5098 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5100 yholecontourvertex[0][0] = ycontourvertex[1];
5101 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5102 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5103 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5104 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5105 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5106 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5107 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5108 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5109 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5110 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5112 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5113 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5114 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5115 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5116 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5117 + 0.5*(fgkEndCapCoverPlateLength[2]
5118 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5119 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5120 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5121 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5122 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5123 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5124 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5126 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5127 - fgkEndCapCoverPlateWidth[0]);
5128 yholecontourvertex[1][1] = ycontourvertex[0];
5129 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5130 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5131 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5132 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5133 - fgkEndCapCoverPlateWidth[0]
5134 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5135 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5136 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5137 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5138 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5140 TGeoVolume* holecontour[2];
5141 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
5142 fSSDAlCoolBlockMedium);
5143 holecontour[0]->SetLineColor(6);
5144 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
5145 fSSDAlCoolBlockMedium);
5146 holecontour[1]->SetLineColor(6);
5147 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5148 + fgkEndCapCoverPlateLength[2],0.,0.);
5149 TGeoTranslation* bigholetrans[3];
5150 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5151 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5152 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5153 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5154 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5155 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5156 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5157 /////////////////////////////////
5158 // Mother Volume Xtru Definition
5159 /////////////////////////////////
5160 const Int_t kmothervertexnumber = 12;
5161 Double_t xmothervertex[kmothervertexnumber];
5162 Double_t ymothervertex[kmothervertexnumber];
5163 xmothervertex[0] = xcontourvertex[0];
5164 xmothervertex[1] = xmothervertex[0];
5165 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5166 xmothervertex[3] = xmothervertex[2];
5167 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5168 xmothervertex[5] = xmothervertex[4];
5169 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5170 xmothervertex[7] = xmothervertex[6];
5171 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5172 + fgkEndCapCoverPlateLength[2];
5173 xmothervertex[9] = xmothervertex[8];
5174 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5175 xmothervertex[11] = xmothervertex[10];
5177 ymothervertex[0] = ycontourvertex[0];
5178 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5179 ymothervertex[2] = ymothervertex[1];
5180 ymothervertex[3] = ycontourvertex[1];
5181 ymothervertex[4] = ymothervertex[3];
5182 ymothervertex[5] = ymothervertex[1];
5183 ymothervertex[6] = ymothervertex[5];
5184 ymothervertex[7] = ymothervertex[0];
5185 ymothervertex[8] = ymothervertex[7];
5186 ymothervertex[9] = ymothervertex[8]
5187 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5188 ymothervertex[10] = ymothervertex[9];
5189 ymothervertex[11] = ymothervertex[8];
5190 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5191 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5192 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5193 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5194 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5195 ////////////////////////////////////////
5197 ////////////////////////////////////////
5198 // TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5199 TGeoTranslation*** endcapcoverplatesmallholetrans;
5200 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5201 Double_t transx[4] = {0,
5202 fgkEndCapCoverPlateSmallHoleSeparation[0],
5203 fgkEndCapCoverPlateSmallHoleSeparation[0]
5204 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5205 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5206 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5208 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5209 endcapcoverplatesmallholetrans[i] =
5210 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5211 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5212 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5213 endcapcoverplatesmallholetrans[i][j] =
5214 new TGeoTranslation(transx[i],
5215 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5217 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5218 index,endcapcoverplatesmallholetrans[i][j]);
5219 mothercoverplate->AddNode(endcapsmallscrewpiece,
5220 index,endcapcoverplatesmallholetrans[i][j]);
5222 if(j<kendcapcoverplatesmallholenumber[1]-1)
5223 mothercoverplate->AddNode(endcapcoverplatebox[0],
5224 index,endcapcoverplatesmallholetrans[i][j]);
5227 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5228 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5229 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5230 mothercoverplate->AddNode(endcapfillingbox,1);
5231 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5232 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5233 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5234 mothercoverplate->AddNode(holecontour[0],1);
5235 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5236 mothercoverplate->AddNode(holecontour[1],1);
5237 mothercoverplate->AddNode(contour,1);
5239 for (Int_t i = 0; i < kendcapcoverplatesmallholenumber[0]; i++)
5240 delete [] endcapcoverplatesmallholetrans[i];
5241 delete [] endcapcoverplatesmallholetrans;
5242 /////////////////////////////////
5243 return mothercoverplate;
5245 ////////////////////////////////////////////////////////////////////////////////
5246 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5247 /////////////////////////////////////////////////////////////
5248 // Getting EndCap Cooling Tube
5249 /////////////////////////////////////////////////////////////
5250 TGeoTorus* endcapcoolingtubetorushape[5];
5251 TGeoVolume* endcapcoolingtubetorus[5];
5252 TGeoTube* endcapcoolingtubeshape[4];
5253 TGeoVolume* endcapcoolingtube[4];
5254 char endcapcoolingtubetorusname[100];
5255 char endcapcoolingtubename[100];
5256 TGeoTorus* endcapcoolingwatertubetorushape[5];
5257 TGeoVolume* endcapcoolingwatertubetorus[5];
5258 TGeoTube* endcapcoolingwatertubeshape[4];
5259 TGeoVolume* endcapcoolingwatertube[4];
5260 char endcapcoolingwatertubetorusname[100];
5261 char endcapcoolingwatertubename[100];
5262 for(Int_t i=0; i<5; i++){
5263 snprintf(endcapcoolingtubetorusname,100,"EndCapCoolingTubeTorus%d",i+1);
5264 snprintf(endcapcoolingtubename,100,"EndCapCoolingTube%d",i+1);
5265 snprintf(endcapcoolingwatertubetorusname,100,"EndCapCoolingWaterTubeTorus%d",i+1);
5266 snprintf(endcapcoolingwatertubename,100,"EndCapCoolingWaterTube%d",i+1);
5268 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5269 fgkEndCapCoolingTubeRadiusMin,
5270 fgkEndCapCoolingTubeRadiusMax,
5271 90.0,fgkEndCapCoolingTubeAngle[3]);
5272 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5273 0.,fgkEndCapCoolingTubeRadiusMin,
5274 90.0,fgkEndCapCoolingTubeAngle[3]);
5277 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5278 :fgkEndCapCoolingTubeAxialRadius[1],
5279 fgkEndCapCoolingTubeRadiusMin,
5280 fgkEndCapCoolingTubeRadiusMax,
5281 0.,fgkEndCapCoolingTubeAngle[i]);
5282 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5283 :fgkEndCapCoolingTubeAxialRadius[1],
5284 0.,fgkEndCapCoolingTubeRadiusMin,
5285 0.,fgkEndCapCoolingTubeAngle[i]);
5287 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5288 endcapcoolingtubetorushape[i],
5289 fSSDCoolingTubePhynox);
5290 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5291 endcapcoolingwatertubetorushape[i],
5292 fSSDCoolingTubeWater);
5293 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5294 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5296 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5297 fgkEndCapCoolingTubeRadiusMax,
5298 0.5*fgkEndCapCoolingTubeLength[i]);
5299 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5300 0.5*fgkEndCapCoolingTubeLength[i]);
5301 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5302 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5303 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5304 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5305 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5306 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5309 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5310 /////////////////////////////////////////
5311 // Transformation for Volume Positioning
5312 /////////////////////////////////////////
5313 TGeoCombiTrans* coolingtubecombitrans[6];
5314 TGeoRotation* coolingtuberot[8];
5315 TGeoTranslation* coolingtubetrans[6];
5316 TGeoHMatrix* coolingtubematrix[4];
5317 TGeoCombiTrans* torustubecombitrans[4];
5318 TGeoRotation* torustuberot[7];
5319 TGeoTranslation* torustubetrans[4];
5320 TGeoHMatrix* torustubematrix[5];
5321 TGeoCombiTrans* coolingwatertubecombitrans[6];
5322 TGeoRotation* coolingwatertuberot[8];
5323 TGeoTranslation* coolingwatertubetrans[6];
5324 TGeoHMatrix* coolingwatertubematrix[4];
5325 TGeoCombiTrans* toruswatertubecombitrans[4];
5326 TGeoRotation* toruswatertuberot[7];
5327 TGeoTranslation* toruswatertubetrans[4];
5328 TGeoHMatrix* toruswatertubematrix[5];
5329 for(Int_t i=0; i<8; i++){
5331 coolingtubetrans[i] = new TGeoTranslation();
5332 coolingwatertubetrans[i] = new TGeoTranslation();
5335 coolingtuberot[i] = new TGeoRotation();
5336 coolingwatertuberot[i] = new TGeoRotation();
5339 torustubetrans[i] = new TGeoTranslation();
5340 toruswatertubetrans[i] = new TGeoTranslation();
5343 torustuberot[i] = new TGeoRotation();
5344 toruswatertuberot[i] = new TGeoRotation();
5347 /////////////////////////////////////////
5348 // Transformation for Inox Volume Positioning
5349 /////////////////////////////////////////
5350 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5351 -endcapcoolingtubeshape[0]->GetDz(),0.);
5352 coolingtuberot[0]->SetAngles(0.,90.,0.);
5353 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5354 *coolingtuberot[0]);
5356 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5357 coolingtuberot[1]->SetAngles(0.,90.,0.);
5358 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5359 *coolingtuberot[1]);
5361 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5362 *CosD(fgkEndCapCoolingTubeAngle[0]),
5363 fgkEndCapCoolingTubeAxialRadius[0]
5364 *SinD(fgkEndCapCoolingTubeAngle[0]),
5366 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5367 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5368 *coolingtuberot[2]);
5370 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5371 * (*coolingtubecombitrans[1]));
5373 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5374 endcapcoolingtubeshape[1]->GetDz());
5375 torustuberot[0]->SetAngles(0.,90.,0.);
5376 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5378 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5380 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5381 -endcapcoolingtubeshape[2]->GetDz(),0.);
5382 coolingtuberot[3]->SetAngles(0.,90.,0.);
5383 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5384 *coolingtuberot[3]);
5385 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5386 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5387 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5389 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5390 endcapcoolingtubeshape[2]->GetDz());
5391 torustuberot[1]->SetAngles(0.,90.,0.);
5392 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5393 torustuberot[2]->SetAngles(180.,0.,0.);
5394 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5395 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5397 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5398 -fgkEndCapCoolingTubeAxialRadius[0]);
5399 torustuberot[3]->SetAngles(0.,90.,0.);
5400 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5401 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5402 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5403 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5405 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5406 fgkEndCapCoolingTubeAxialRadius[0],0.);
5407 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5408 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5409 *coolingtuberot[5]);
5410 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5411 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5412 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5414 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5415 endcapcoolingtubeshape[0]->GetDz());
5416 torustuberot[5]->SetAngles(0.,90.,0.);
5417 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5418 torustuberot[6]->SetAngles(-90.,0.,0.);
5419 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5420 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5422 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5423 endcapcoolingtubeshape[3]->GetDz(),0.);
5424 coolingtuberot[6]->SetAngles(0.,90.,0.);
5425 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5426 *coolingtuberot[6]);
5427 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5428 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5429 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5430 /////////////////////////////////////////
5431 // Transformation for Water Volume Positioning
5432 /////////////////////////////////////////
5433 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5434 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5435 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5436 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5437 *coolingwatertuberot[0]);
5439 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5440 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5441 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5442 *coolingwatertuberot[1]);
5444 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5445 *CosD(fgkEndCapCoolingTubeAngle[0]),
5446 fgkEndCapCoolingTubeAxialRadius[0]
5447 *SinD(fgkEndCapCoolingTubeAngle[0]),
5449 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5450 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5451 *coolingwatertuberot[2]);
5453 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5454 * (*coolingwatertubecombitrans[1]));
5456 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5457 endcapcoolingwatertubeshape[1]->GetDz());
5458 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5459 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5460 *toruswatertuberot[0]);
5462 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5463 * (*toruswatertubecombitrans[0]));
5465 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5466 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5467 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5468 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5469 *coolingwatertuberot[3]);
5470 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5471 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5472 * (*coolingwatertubecombitrans[3]));
5473 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5475 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5476 endcapcoolingwatertubeshape[2]->GetDz());
5477 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5478 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5479 *toruswatertuberot[1]);
5480 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5481 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5482 * (*toruswatertubecombitrans[1]));
5483 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5485 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5486 -fgkEndCapCoolingTubeAxialRadius[0]);
5487 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5488 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5489 *toruswatertuberot[3]);
5490 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5491 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5492 * (*toruswatertubecombitrans[2]));
5493 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5495 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5496 fgkEndCapCoolingTubeAxialRadius[0],0.);
5497 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5498 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5499 *coolingwatertuberot[5]);
5500 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5501 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5502 * (*coolingwatertubecombitrans[4]));
5503 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5505 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5506 endcapcoolingwatertubeshape[0]->GetDz());
5507 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5508 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5509 *toruswatertuberot[5]);
5510 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5511 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5512 * (*toruswatertubecombitrans[3]));
5513 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5515 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5516 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5517 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5518 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5519 *coolingwatertuberot[6]);
5520 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5521 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5522 * (*coolingwatertubecombitrans[5]));
5523 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5524 /////////////////////////////////////////
5525 // Positioning Volumes
5526 /////////////////////////////////////////
5527 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5528 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5530 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5531 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5533 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5534 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5536 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5537 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5539 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5540 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5542 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5543 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5545 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5546 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5548 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5549 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5551 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5552 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5554 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5555 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5556 /////////////////////////////////////////////////////////////
5557 // Deallocating memory
5558 /////////////////////////////////////////////////////////////
5559 for(Int_t i=0; i<8; i++){
5561 delete coolingtubetrans[i];
5562 delete coolingwatertubetrans[i];
5564 delete coolingtubecombitrans[i];
5565 delete coolingwatertubecombitrans[i];
5569 delete coolingtuberot[i];
5570 delete coolingwatertuberot[i];
5573 delete torustubetrans[i];
5574 delete toruswatertubetrans[i];
5575 delete torustubecombitrans[i];
5576 delete toruswatertubecombitrans[i];
5579 delete torustuberot[i];
5580 delete toruswatertuberot[i];
5583 /////////////////////////////////////////////////////////////
5584 return endcapcoolingtubemother;
5586 ////////////////////////////////////////////////////////////////////////////////
5587 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5588 /////////////////////////////////////////////////////////////
5589 // Getting EndCap Cover Side
5590 /////////////////////////////////////////////////////////////
5591 const Int_t kendcapcoverholenumber[2] = {7,5};
5592 const Int_t kvertexnumber = 15;
5593 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5595 xvertex[1] = xvertex[0];
5596 xvertex[2] = fgkEndCapSideCoverLength[0];
5597 xvertex[3] = fgkEndCapSideCoverLength[1];
5598 xvertex[4] = xvertex[3];
5599 xvertex[5] = fgkEndCapSideCoverLength[2];
5600 xvertex[6] = xvertex[5];
5601 xvertex[7] = xvertex[2];
5602 xvertex[8] = xvertex[7];
5603 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5604 xvertex[10] = xvertex[9];
5605 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5606 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5607 * fgkEndCapSideCoverLength[4];
5608 xvertex[12] = xvertex[11];
5609 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5610 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5611 * fgkEndCapSideCoverLength[4];
5612 xvertex[14] = xvertex[13];
5614 yvertex[1] = fgkEndCapSideCoverWidth[0];
5615 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5616 yvertex[3] = yvertex[2];
5617 yvertex[4] = fgkEndCapSideCoverWidth[1];
5618 yvertex[5] = yvertex[4];
5619 yvertex[6] = yvertex[0];
5620 yvertex[7] = yvertex[6];
5621 yvertex[8] = fgkEndCapSideCoverWidth[6];
5622 yvertex[9] = yvertex[8];
5623 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5624 yvertex[11] = yvertex[10];
5625 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5626 yvertex[13] = yvertex[12];
5627 yvertex[14] = yvertex[6];
5628 TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5629 endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5630 endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5631 endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5632 endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5633 TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5634 endcapsidecovershapein->SetName("endcapsidecovershapein");
5635 endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5636 endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5637 endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5640 TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
5641 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5642 endcapsidecovershape,fSSDCoolingTubePhynox);
5643 endcapsidecover->SetLineColor(fColorPhynox);
5644 ////////////////////////////////////////////
5645 // Defininition of Mother Volume
5646 ////////////////////////////////////////////
5647 const Int_t kmothervertexnumber = 7;
5648 Double_t xmothervertex[kmothervertexnumber];
5649 Double_t ymothervertex[kmothervertexnumber];
5650 for(Int_t i=0; i<kmothervertexnumber; i++){
5651 xmothervertex[i] = xvertex[i];
5652 ymothervertex[i] = yvertex[i];
5654 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5655 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5656 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5657 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5658 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5659 endcapsidecovermothershape,fSSDAir);
5660 ////////////////////////////////////////////
5661 endcapsidecovermother->AddNode(endcapsidecover,1);
5662 TGeoBBox* endcapsidecoverboxshape[4];
5663 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5664 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5665 0.5*fgkEndCapSideCoverLength[4],
5666 0.5*fgkEndCapSideCoverThickness);
5667 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5668 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5669 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5670 - fgkEndCapSideCoverLength[4]),
5671 0.5*fgkEndCapSideCoverThickness);
5672 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5673 0.5*fgkEndCapSideCoverLength[4],
5674 0.5*fgkEndCapSideCoverThickness);
5675 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5676 0.5*fgkEndCapSideCoverWidth[5],
5677 0.5*fgkEndCapSideCoverThickness);
5678 TGeoVolume* endcapsidecoverbox[4];
5679 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5680 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5681 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5682 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5683 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5684 // TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5685 TGeoTranslation** endcapsidecoverboxtrans;
5686 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5687 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5688 + fgkEndCapSideCoverLength[0],
5689 endcapsidecoverboxshape[0]->GetDY()
5690 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5691 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5693 endcapsidecoverboxshape[1]->GetDY()
5695 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5697 endcapsidecoverboxshape[2]->GetDY()
5699 + 2.*endcapsidecoverboxshape[1]->GetDY()
5700 + fgkEndCapSideCoverWidth[5],0.);
5701 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5702 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5703 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5704 for(Int_t i=0; i<2; i++)
5705 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5706 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5707 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5708 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5709 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5710 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5711 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5712 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5714 for(Int_t i=0; i<2; i++)
5715 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5716 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5717 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5718 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5719 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5720 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5721 +fgkEndCapSideCoverLength[4]),0.0);
5722 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5723 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5724 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5725 +i*(kendcapcoverholenumber[1]-1)+j]);
5727 delete [] endcapsidecoverboxtrans;
5728 return endcapsidecovermother;
5730 ////////////////////////////////////////////////////////////////////////////////
5731 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5732 ////////////////////////////////////////////////////////////////////////////////
5733 // Method returning Interface Card A, Interface Card B, Supply Card
5734 ////////////////////////////////////////////////////////////////////////////////
5735 /////////////////////
5737 /////////////////////
5738 // Electronic Board Back Al Plane
5739 const Int_t kelectboardbackvertexnumber = 8;
5740 Double_t xelectboardback[kelectboardbackvertexnumber];
5741 Double_t yelectboardback[kelectboardbackvertexnumber];
5742 xelectboardback[0] = 0.0;
5743 xelectboardback[1] = xelectboardback[0];
5744 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5745 xelectboardback[3] = xelectboardback[2];
5746 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5747 xelectboardback[5] = xelectboardback[4];
5748 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5749 xelectboardback[7] = xelectboardback[6];
5751 yelectboardback[0] = 0.0;
5752 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5753 yelectboardback[2] = yelectboardback[1];
5754 yelectboardback[3] = yelectboardback[0];
5755 yelectboardback[4] = yelectboardback[3];
5756 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5757 yelectboardback[6] = yelectboardback[5];
5758 yelectboardback[7] = yelectboardback[4];
5759 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5760 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5761 xelectboardback,yelectboardback);
5762 electboardbackshape->DefineSection(0,0.0);
5763 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5764 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5765 electboardbackshape,fSSDSupportRingAl);
5766 electboardback->SetLineColor(fColorAl);
5767 // Electronic Board Kapton Layer
5768 const Int_t kelectlayervertexnumber = 8;
5769 Double_t xelectlayer[kelectlayervertexnumber];
5770 Double_t yelectlayer[kelectlayervertexnumber];
5771 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5772 xelectlayer[1] = xelectlayer[0];
5773 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5774 xelectlayer[3] = xelectlayer[2];
5775 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5777 yelectlayer[0] = 0.0;
5778 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5779 yelectlayer[2] = yelectlayer[1];
5780 yelectlayer[3] = yelectlayer[0];
5781 yelectlayer[4] = yelectlayer[3];
5782 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5783 yelectlayer[6] = yelectlayer[5];
5784 yelectlayer[7] = yelectlayer[4];
5785 TGeoXtru* electlayershape = new TGeoXtru(2);
5786 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5787 electlayershape->DefineSection(0,0.0);
5788 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5789 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5790 electlayershape,fSSDKaptonFlexMedium);
5791 electlayer->SetLineColor(fColorKapton);
5792 // JMD Connector Female
5793 const Int_t kjmdconnectorvertexnumber = 6;
5794 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5795 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5796 xjmdconnectorvertex[0] = 0.0;
5797 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5798 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5799 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5800 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5801 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5803 yjmdconnectorvertex[0] = 0.0;
5804 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5805 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5806 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5807 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5808 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5809 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5810 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5811 yjmdconnectorvertex);
5812 jmdconnectorshape->DefineSection(0,0.0);
5813 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5814 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5815 jmdconnectorshape,fSSDMountingBlockMedium);
5816 jmdconnector->SetLineColor(fColorG10);
5817 // Top Cable Connector
5818 const Int_t kcableconnectorvertexnumber = 8;
5819 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5820 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5821 xconnectorvertex[0] = 0.0;
5822 xconnectorvertex[1] = xconnectorvertex[0];
5823 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5824 xconnectorvertex[3] = xconnectorvertex[2];
5825 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5826 - fgkEndCapCardCableConnectorLength[2];
5827 xconnectorvertex[5] = xconnectorvertex[4];
5828 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5829 xconnectorvertex[7] = xconnectorvertex[6];
5831 yconnectorvertex[0] = 0.0;
5832 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5833 yconnectorvertex[2] = yconnectorvertex[1];
5834 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5835 yconnectorvertex[4] = yconnectorvertex[3];
5836 yconnectorvertex[5] = yconnectorvertex[1];
5837 yconnectorvertex[6] = yconnectorvertex[5];
5838 yconnectorvertex[7] = yconnectorvertex[0];
5839 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5840 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5842 cableconnectorshape->DefineSection(0,0.0);
5843 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5844 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5845 cableconnectorshape,fSSDMountingBlockMedium);
5846 cableconnector->SetLineColor(fColorG10);
5848 TGeoBBox* endcapstripconnectionshape =
5849 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5850 0.5*fgkEndCapStripConnectionThickness,
5851 0.5*fgkEndCapStripConnectionWidth);
5852 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5853 endcapstripconnectionshape,
5855 endcapstripconnection->SetLineColor(fColorAl);
5857 const Int_t kcardBvertexnumber = 12;
5858 Double_t xcardBvertexnumber[kcardBvertexnumber];
5859 Double_t ycardBvertexnumber[kcardBvertexnumber];
5861 xcardBvertexnumber[0] = 0.0;
5862 xcardBvertexnumber[1] = xcardBvertexnumber[0];
5863 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5864 xcardBvertexnumber[3] = xcardBvertexnumber[2];
5865 xcardBvertexnumber[4] = xcardBvertexnumber[1];
5866 xcardBvertexnumber[5] = xcardBvertexnumber[4];
5867 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5868 xcardBvertexnumber[7] = xcardBvertexnumber[6];
5869 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5870 xcardBvertexnumber[9] = xcardBvertexnumber[8];
5871 xcardBvertexnumber[10] = xcardBvertexnumber[7];
5872 xcardBvertexnumber[11] = xcardBvertexnumber[10];
5874 ycardBvertexnumber[0] = 0.0;
5875 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
5876 ycardBvertexnumber[2] = ycardBvertexnumber[1];
5877 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5878 ycardBvertexnumber[4] = ycardBvertexnumber[3];
5879 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5880 ycardBvertexnumber[6] = ycardBvertexnumber[5];
5881 ycardBvertexnumber[7] = ycardBvertexnumber[4];
5882 ycardBvertexnumber[8] = ycardBvertexnumber[7];
5883 ycardBvertexnumber[9] = ycardBvertexnumber[1];
5884 ycardBvertexnumber[10] = ycardBvertexnumber[9];
5885 ycardBvertexnumber[11] = ycardBvertexnumber[0];
5887 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5888 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5889 interfacecardBshape->DefineSection(0,0.);
5890 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5891 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5892 fSSDMountingBlockMedium);
5893 interfacecardB->SetLineColor(46);
5894 // Interface Card B Electronic Board
5895 const Int_t kelectboardcardBvertexnumber = 14;
5896 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5897 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5899 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5900 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
5901 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
5902 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
5903 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
5904 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
5905 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
5906 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
5907 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
5908 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
5909 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
5910 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
5911 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
5912 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
5914 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
5915 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
5916 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
5917 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
5918 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
5919 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
5920 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
5921 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
5922 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
5923 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
5924 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
5925 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
5926 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
5927 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
5929 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
5930 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
5931 xelectboardcardBvertex,yelectboardcardBvertex);
5932 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
5933 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
5934 + fgkEndCapInterfaceElectBoardCardBThickness);
5935 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
5937 electboardcardB->SetLineColor(fColorAl);
5938 // Generating Stiffener 2
5939 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
5940 0.5*fgkEndCapStiffenerThickness,
5941 0.5*fgkEndCapStiffenerLength);
5942 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
5943 endcapstiffener->SetLineColor(fColorAl);
5944 // Generating Mother Interface Card B Container
5945 const Int_t kinterfacecardBmothervertexnumber = 10;
5946 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5947 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5949 xinterfacecardBmothervertex[0] = 0.0;
5950 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
5951 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
5952 + fgkEndCapInterfaceCardBThickness;
5953 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
5954 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
5955 + fgkEndCapInterfaceElectBoardCardBThickness;
5956 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
5957 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
5958 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
5959 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
5960 + fgkEndCapCardJMDConnectorLength[0];
5961 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
5963 yinterfacecardBmothervertex[0] = 0.0;
5964 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
5965 + fgkEndCapInterfaceCardBWidth[1]
5966 + fgkEndCapInterfaceCardBWidth[2];
5967 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
5968 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
5969 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
5970 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
5971 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
5972 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
5973 + fgkEndCapCardJMDConnectorWidth[0]
5974 + fgkEndCapCardJMDConnectorWidth[1];
5975 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
5976 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
5977 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
5978 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
5979 xinterfacecardBmothervertex,
5980 yinterfacecardBmothervertex);
5981 interfacecardBmothershape->DefineSection(0,-1.e-15);
5982 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
5983 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
5984 interfacecardBmothershape,fSSDAir);
5985 electboardcardB->SetLineColor(fColorAl);
5986 // Positioning Volumes Mother Interface Card B Container
5987 TGeoRotation* interfacecardBrot = new TGeoRotation();
5988 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
5989 interfacecardBrot->SetAngles(90.,-90.,-90.);
5990 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
5991 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
5992 TGeoRotation* electboardcardBrot = new TGeoRotation();
5993 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
5994 electboardcardBrot->SetAngles(90.,90.,-90.);
5995 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
5996 TGeoCombiTrans* electboardcardBcombitrans =
5997 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
5998 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
5999 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6000 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6001 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6002 TGeoTranslation* jmdconnectorcardBtrans[3];
6003 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6004 for(Int_t i=0; i<3; i++){
6005 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6006 + fgkEndCapCardJMDConnectorLength[0],
6007 fgkEndCapCardElectBoardLayerWidth[1],
6008 0.5*fgkEndCapCardJMDConnectorThickness
6009 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6010 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6011 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6012 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6013 *jmdconnectorcardBrot);
6014 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6016 // Mother Supply Card Container
6017 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6018 // Interface Card Container
6019 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6020 // Placing Volumes in Mother Supply Card Container
6021 // JMD Connector Positioning
6022 TGeoTranslation* jmdconnectortrans[2];
6023 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6024 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6025 fgkEndCapCardElectBoardBackLength[0]
6026 - fgkEndCapCardJMDConnectorThickness
6027 - fgkEndCapCardJMDConnectorToLayer);
6028 TGeoRotation* jmdconnectorot = new TGeoRotation();
6029 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6030 + 2.*fgkEndCapCardJMDConnectorLength[0]
6031 + 2.*fgkEndCapCardElectBoardLayerThickness,
6032 fgkEndCapCardElectBoardLayerWidth[1],
6033 fgkEndCapCardJMDConnectorThickness
6034 + fgkEndCapCardJMDConnectorToLayer);
6035 jmdconnectorot->SetAngles(90.,180.,-90);
6036 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6038 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6039 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6040 // Top Cable Connector Placing
6041 TGeoRotation* cableconnectorot[2];
6042 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6043 TGeoTranslation* cableconnectortrans[3];
6044 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6045 cableconnectorot[0]->SetAngles(90.,0.,0.);
6046 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6047 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6048 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6049 *cableconnectorot[0]);
6050 TGeoHMatrix* cableconnectormatrix[2];
6051 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6052 new TGeoHMatrix((*cableconnectorot[1])
6053 *(*cableconnectorcombitrans));
6054 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6055 - fgkEndCapCardCableConnectorThickness,
6056 fgkEndCapCardCableConnectorLength[0]
6057 + fgkEndCapCardCableConnectorToLayer);
6058 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6059 - 2.*fgkEndCapCardCableConnectorThickness
6060 - fgkEndCapCardCableConnectorDistance,
6061 fgkEndCapCardCableConnectorLength[0]
6062 + fgkEndCapCardCableConnectorToLayer);
6063 for(Int_t i=0; i<2; i++){
6064 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6065 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6067 TGeoRotation* electboardbackrot = new TGeoRotation();
6068 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6069 electboardbackrot->SetAngles(90.,-90.,-90.);
6070 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6071 + fgkEndCapCardJMDConnectorLength[0]
6072 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6073 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6074 *electboardbackrot);
6075 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6076 // Electronic Board Kapton Layer Positioning
6077 TGeoRotation* electlayerrot = new TGeoRotation();
6078 TGeoTranslation* electlayertrans[2];
6079 TGeoCombiTrans* electlayercombitrans[2];
6080 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6081 electlayerrot->SetAngles(90.,-90.,-90.);
6082 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6083 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6084 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6085 + 2.*fgkEndCapCardElectBoardLayerThickness
6086 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6087 for(Int_t i=0; i<2; i++){
6088 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6089 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6091 // Placing Volumes in Mother Interface Card Container
6092 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6093 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6094 for(Int_t i=0; i<2; i++){
6095 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6097 /////////////////////////////////////////////////////////////
6098 // Generation of Card Interface Container
6099 /////////////////////////////////////////////////////////////
6100 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6101 - fgkEndCapCardJMDConnectorLength[0]
6102 - fgkEndCapInterfaceCardBThickness
6103 - 9.*fgkEndCapStripConnectionThickness
6104 - 8.*fgkEndCapCardElectBoardBackThickness;
6105 const Int_t kcardinterfacecontainervertexnumber = 14;
6106 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6107 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6108 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6109 - 7.0*fgkEndCapStripConnectionThickness;
6110 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6111 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6112 + fgkEndCapStripConnectionThickness
6113 - fgkEndCapCardElectBoardLayerThickness
6114 - fgkEndCapCardCableConnectorWidth[0];
6115 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6116 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6117 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6118 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6119 + 2.0*fgkEndCapStripConnectionThickness;
6120 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6121 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6122 + fgkEndCapInterfaceCardBThickness;
6123 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6124 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6125 + fgkEndCapInterfaceElectBoardCardBThickness;
6126 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6127 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6128 - fgkEndCapInterfaceElectBoardCardBThickness
6129 + fgkEndCapCardJMDConnectorLength[0]
6130 + stiffenertransx+fgkEndCapStiffenerWidth;
6131 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6133 ycardinterfacecontainervertex[0] = 0.;
6134 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6135 + fgkEndCapCardJMDConnectorWidth[0]
6136 + fgkEndCapCardJMDConnectorWidth[1];
6137 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6138 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6139 - fgkEndCapStripConnectionWidth;
6140 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6141 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6142 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6143 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6144 + fgkEndCapInterfaceCardBWidth[1]
6145 + fgkEndCapInterfaceCardBWidth[2];
6146 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6147 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6148 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6149 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6150 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6151 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6153 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6154 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6155 xcardinterfacecontainervertex,
6156 ycardinterfacecontainervertex);
6157 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6158 - fgkEndCapCardElectBoardBackLength[0]));
6159 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6160 + fgkEndCapCardElectBoardBackLength[0]));
6161 TGeoVolume** cardinterfacecontainer;
6162 cardinterfacecontainer = new TGeoVolume*[4];
6163 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6164 interfacecardmothershape,fSSDAir);
6165 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6166 interfacecardmothershape,fSSDAir);
6167 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6168 interfacecardmothershape,fSSDAir);
6169 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6170 interfacecardmothershape,fSSDAir);
6171 /////////////////////////////////
6172 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6173 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6174 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6175 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6176 /////////////////////////////////
6177 TGeoRotation* endcapstripconnectionrot[2];
6178 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6179 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6180 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6181 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6182 * (*endcapstripconnectionrot[0]));
6183 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6184 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6185 -0.5*fgkEndCapCardElectBoardBackThickness,
6186 fgkEndCapCardElectBoardBackWidth[0]
6187 -endcapstripconnectionshape->GetDZ(),
6188 0.5*fgkEndCapCardElectBoardBackLength[0]);
6189 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6190 TGeoTranslation* cardinterfacetrans[9];
6191 TGeoHMatrix* cardinterfacematrix[9];
6192 for(Int_t i=0; i<7; i++){
6193 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6194 + fgkEndCapCardElectBoardBackThickness),
6196 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6197 * (*endcapstripconnectionmatrix));
6199 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6200 + fgkEndCapCardElectBoardBackThickness),
6202 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6203 * (*endcapstripconnectionmatrix));
6204 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6205 + fgkEndCapCardElectBoardBackThickness),
6207 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6208 * (*endcapstripconnectionmatrix));
6210 for(Int_t i=0; i<4; i++){
6211 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6212 cardinterfacematrix[7]);
6213 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6214 cardinterfacematrix[8]);
6216 TGeoTranslation* mothersupplycardtrans =
6217 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6218 + 2.*fgkEndCapCardJMDConnectorLength[0]
6219 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6220 TGeoHMatrix* mothersupplycardmatrix[7];
6221 Int_t index[4] = {1,1,1,1};
6222 for(Int_t i=0; i<7; i++){
6223 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6224 * (*mothersupplycardtrans));
6225 for(Int_t j=0; j<4; j++){
6227 case 0: //Layer5 EndCap Left Side
6228 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6229 cardinterfacematrix[i]);
6231 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6232 mothersupplycardmatrix[i]);
6237 case 1: //Layer5 EndCap Rigth Side
6238 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6239 cardinterfacematrix[i]);
6241 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6242 mothersupplycardmatrix[i]);
6246 case 2: //Layer6 EndCap Left Side
6247 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6248 cardinterfacematrix[i]);
6250 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6251 mothersupplycardmatrix[i]);
6255 case 3: //Layer6 EndCap Right Side
6256 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6257 cardinterfacematrix[i]);
6258 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6259 mothersupplycardmatrix[i]);
6265 // Positioning Interface
6266 TGeoTranslation* motherinterfacecardtrans =
6267 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6268 +0.5*fgkEndCapCardElectBoardBackThickness
6269 -fgkEndCapCardElectBoardLayerThickness
6270 +fgkEndCapStripConnectionThickness,0.,0.);
6271 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6272 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6273 // Positioning Interface Card B
6274 TGeoTranslation* interfacecardBmothertrans =
6275 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6276 + 2.*fgkEndCapStripConnectionThickness
6277 + fgkEndCapCardElectBoardBackThickness,0.,
6278 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6279 - fgkEndCapCardElectBoardBackLength[0]));
6280 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6281 interfacecardBmothertrans);
6282 // Positioning Stiffener
6283 TGeoTranslation* endcapstiffenertrans =
6284 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6285 + 2.0*fgkEndCapStripConnectionThickness
6286 + fgkEndCapInterfaceCardBThickness
6287 + fgkEndCapCardJMDConnectorLength[0]
6289 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6290 endcapstiffenershape->GetDZ()
6291 - 0.5*(fgkEndCapStiffenerLength
6292 - fgkEndCapCardElectBoardBackLength[0]));
6293 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6294 /////////////////////////////////////////////////////////////
6295 // Deallocating memory
6296 /////////////////////////////////////////////////////////////
6297 delete interfacecardBrot;
6298 delete interfacecardBtrans;
6299 delete electboardcardBtrans;
6300 delete electboardcardBrot;
6301 delete jmdconnectorcardBrot;
6302 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6303 delete jmdconnectorot;
6304 delete jmdconnectortrans[1];
6305 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6306 delete cableconnectorcombitrans;
6307 delete electboardbacktrans;
6308 delete electboardbackrot;
6309 delete electlayerrot;
6310 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6311 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6312 delete mothersupplycardtrans;
6313 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6314 /////////////////////////////////////////////////////////////
6315 return cardinterfacecontainer;
6317 ////////////////////////////////////////////////////////////////////////////////
6318 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6319 /////////////////////////////////////////////////////////////
6320 // Method returning EndCap Mother Volume
6321 /////////////////////////////////////////////////////////////
6322 const Int_t kendcapcoverplatesmallholenumber = 9;
6323 Double_t endcapmotherorigin[3];
6324 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6325 + 0.5 *(fgkEndCapCoverPlateLength[3]
6326 + 2.0 * fgkEndCapCoverPlateLength[2]);
6327 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6328 - fgkEndCapCoverPlateWidth[2]
6329 - (kendcapcoverplatesmallholenumber-1)
6330 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6331 + 0.5*(fgkEndCapSideCoverLength[2]
6332 + fgkEndCapCoverPlateWidth[1]
6333 - fgkEndCapCoverPlateWidth[0])
6334 - (fgkEndCapCoverPlateWidth[1]
6335 - fgkEndCapCoverPlateWidth[0]);
6336 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6337 + 2.*fgkEndCapCoolingTubeRadiusMax
6338 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6339 + fgkEndCapSideCoverWidth[1]
6340 + fgkEndCapSideCoverThickness
6341 + fgkEndCapKaptonFoilThickness);
6342 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6343 + 2.0* fgkEndCapCoverPlateLength[2]
6344 + 2.0* fgkEndCapSideCoverThickness),
6345 0.5* (fgkEndCapSideCoverLength[2]
6346 + fgkEndCapCoverPlateWidth[1]
6347 - fgkEndCapCoverPlateWidth[0]),
6348 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6349 + fgkEndCapSideCoverWidth[1]
6350 + fgkEndCapSideCoverThickness
6351 + fgkEndCapKaptonFoilThickness),
6352 endcapmotherorigin);
6353 TGeoVolume** endcapassembly;
6354 endcapassembly = new TGeoVolume*[4];
6355 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6356 endcapmothershape,fSSDAir);
6357 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6358 endcapmothershape,fSSDAir);
6359 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6360 endcapmothershape,fSSDAir);
6361 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6362 endcapmothershape,fSSDAir);
6363 /////////////////////////////////
6364 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6365 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6366 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6367 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6368 /////////////////////////////////
6369 /////////////////////////////////////////////////////
6370 // Placing Endcap Cover Plate
6371 /////////////////////////////////////////////////////
6372 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6373 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6374 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6375 TGeoCombiTrans* endcapcoverplatecombitrans =
6376 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6377 endcapcoverplaterot);
6378 TGeoTranslation* endcapcoverplatetrans =
6379 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6380 TGeoHMatrix* endcapcoverplatematrix =
6381 new TGeoHMatrix((*endcapcoverplatetrans)
6382 * (*endcapcoverplatecombitrans));
6383 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6384 /////////////////////////////////////////////////////
6385 // Placing Endcap Side Cover
6386 /////////////////////////////////////////////////////
6387 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6388 TGeoRotation* endcapsidecoverot[2];
6389 TGeoCombiTrans* endcapsidecovercombitrans[3];
6390 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6391 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6392 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6393 - 0.5*(fgkEndCapCoverPlateWidth[0]
6394 - fgkEndCapCoverPlateWidth[2]
6395 - (kendcapcoverplatesmallholenumber-1)
6396 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6397 + 0.*fgkEndCapCoverPlateWidth[0]
6398 + fgkEndCapSideCoverLength[2],
6399 0.5*(fgkEndCapSideCoverThickness
6400 + fgkEndCapCoverPlateThickness)
6401 - 0.5*fgkEndCapCoverPlateThickness,
6402 endcapsidecoverot[0]);
6403 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6404 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6405 0.5*fgkEndCapCoverPlateThickness
6406 -fgkEndCapSideCoverWidth[1],
6407 endcapsidecoverot[1]);
6408 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6409 +fgkEndCapCoverPlateLength[3]
6410 +2.*fgkEndCapCoverPlateLength[2]
6411 +fgkEndCapSideCoverThickness,0.0,
6412 0.5*fgkEndCapCoverPlateThickness
6413 -fgkEndCapSideCoverWidth[1],
6414 endcapsidecoverot[1]);
6415 TGeoHMatrix* endcapsidecovermatrix[2];
6416 for(Int_t i=0; i<2; i++){
6417 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6418 * (*endcapsidecovercombitrans[0]));
6419 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6420 endcapsidecovermatrix[i]);
6422 /////////////////////////////////////////////////////
6423 // Placing Endcap Cooling Tube
6424 /////////////////////////////////////////////////////
6425 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6426 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6427 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6428 TGeoCombiTrans* endcapccolingtubecombitrans
6429 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6430 + fgkEndCapCoolingTubeAxialRadius[1])
6431 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6432 - fgkEndCapCoolingTubeToCoverSide,
6433 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6434 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6435 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6436 endcapccolingtubecombitrans);
6437 /////////////////////////////////////////////////////
6439 /////////////////////////////////////////////////////
6440 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6441 fgkEndCapCoverPlateScrewRadiusMin};
6442 Int_t screwcoverplatedgesnumber[2] = {20,20};
6443 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6444 fgkEndCapCoverPlateThickness
6445 + fgkEndCapCoolingTubeRadiusMax};
6446 TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6447 screwcoverplatedgesnumber,
6448 screwcoverplatesection);
6449 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6450 screwcoverplateshape,
6451 fSSDCoolingTubePhynox);
6452 screwcoverplate->SetLineColor(12);
6453 Double_t transx[4] = {0,
6454 fgkEndCapCoverPlateSmallHoleSeparation[0],
6455 fgkEndCapCoverPlateSmallHoleSeparation[0]
6456 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6457 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6458 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6459 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6460 // TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6461 TGeoTranslation*** endcapcoverplatescrewtrans;
6462 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6464 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6465 endcapcoverplatescrewtrans[i] =
6466 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6467 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6468 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6469 if(index==1||index==9||index==28||index==36){
6470 endcapcoverplatescrewtrans[i][j] =
6471 new TGeoTranslation(transx[i],
6472 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6473 fgkEndCapSideCoverThickness);
6476 endcapcoverplatescrewtrans[i][j] =
6477 new TGeoTranslation(transx[i],
6478 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6482 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6483 endcapcoverplatescrewtrans[i][j]);
6486 /////////////////////////////////////////////////////
6487 // Placing Cover Plate Clips
6488 /////////////////////////////////////////////////////
6489 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6490 0.5*fgkEndCapCoverPlateClipWidth,
6491 0.5*fgkEndCapSideCoverThickness);
6492 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6493 endcapcoverplateclipshape,
6494 fSSDCoolingTubePhynox);
6495 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6496 0.5*fgkEndCapCoverPlateDownClipWidth,
6497 0.5*fgkEndCapSideCoverThickness);
6498 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6499 endcapcoverplatedownclipshape,
6500 fSSDCoolingTubePhynox);
6501 TGeoTranslation* endcapcoverplatecliptrans[4];
6502 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6503 - fgkEndCapCoverPlateLength[0]
6504 - fgkEndCapSideCoverThickness,
6506 0.5*(fgkEndCapSideCoverThickness
6507 + fgkEndCapCoverPlateThickness));
6508 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6509 - fgkEndCapCoverPlateLength[0]
6510 - fgkEndCapSideCoverThickness,
6511 (kendcapcoverplatescrewnumber[1]-1)
6512 * fgkEndCapSideCoverWidth[5],
6513 0.5*(fgkEndCapSideCoverThickness
6514 + fgkEndCapCoverPlateThickness));
6515 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6516 - fgkEndCapCoverPlateLength[0]
6517 + fgkEndCapCoverPlateLength[1]
6518 + 2.*fgkEndCapCoverPlateLength[0]
6519 - fgkEndCapCoverPlateClipLength
6520 + fgkEndCapSideCoverThickness,
6522 0.5*(fgkEndCapSideCoverThickness
6523 + fgkEndCapCoverPlateThickness));
6524 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6525 - fgkEndCapCoverPlateLength[0]
6526 + fgkEndCapCoverPlateLength[1]
6527 + 2.*fgkEndCapCoverPlateLength[0]
6528 - fgkEndCapCoverPlateClipLength
6529 + fgkEndCapSideCoverThickness,
6530 (kendcapcoverplatescrewnumber[1]-1)
6531 * fgkEndCapSideCoverWidth[5],
6532 0.5*(fgkEndCapSideCoverThickness
6533 + fgkEndCapCoverPlateThickness));
6534 endcapcoverplateclip->SetLineColor(fColorPhynox);
6535 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6536 for(Int_t i=0; i<4; i++)
6537 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6538 endcapcoverplatecliptrans[i]);
6539 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6540 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6541 - fgkEndCapCoverPlateLength[0]
6542 - fgkEndCapSideCoverThickness,
6543 0.5*(fgkEndCapCoverPlateDownClipWidth
6544 - fgkEndCapCoverPlateClipWidth),
6545 0.5*(fgkEndCapSideCoverThickness
6546 + fgkEndCapCoverPlateThickness)
6547 - fgkEndCapSideCoverWidth[1]
6548 - fgkEndCapSideCoverThickness);
6549 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6550 - fgkEndCapCoverPlateLength[0]
6551 - fgkEndCapSideCoverThickness,
6552 0.5*(fgkEndCapCoverPlateDownClipWidth
6553 - fgkEndCapCoverPlateClipWidth)
6554 + fgkEndCapSideCoverLength[2]
6555 - fgkEndCapCoverPlateDownClipWidth,
6556 0.5*(fgkEndCapSideCoverThickness
6557 + fgkEndCapCoverPlateThickness)
6558 - fgkEndCapSideCoverWidth[1]
6559 - fgkEndCapSideCoverThickness);
6560 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6561 - fgkEndCapCoverPlateLength[0]
6562 + fgkEndCapSideCoverThickness
6563 + fgkEndCapCoverPlateLength[1]
6564 + 2.0*fgkEndCapCoverPlateLength[0]
6565 - fgkEndCapCoverPlateDownClipLength,
6566 0.5*(fgkEndCapCoverPlateDownClipWidth
6567 - fgkEndCapCoverPlateClipWidth),
6568 0.5*(fgkEndCapSideCoverThickness
6569 + fgkEndCapCoverPlateThickness)
6570 - fgkEndCapSideCoverWidth[1]
6571 - fgkEndCapSideCoverThickness);
6572 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6573 - fgkEndCapCoverPlateLength[0]
6574 + fgkEndCapSideCoverThickness
6575 + fgkEndCapCoverPlateLength[1]
6576 + 2.0*fgkEndCapCoverPlateLength[0]
6577 - fgkEndCapCoverPlateDownClipLength,
6578 0.5*(fgkEndCapCoverPlateDownClipWidth
6579 - fgkEndCapCoverPlateClipWidth)
6580 + fgkEndCapSideCoverLength[2]
6581 - fgkEndCapCoverPlateDownClipWidth,
6582 0.5*(fgkEndCapSideCoverThickness
6583 + fgkEndCapCoverPlateThickness)
6584 - fgkEndCapSideCoverWidth[1]
6585 - fgkEndCapSideCoverThickness);
6586 for(Int_t i=0; i<4; i++)
6587 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6588 endcapcoverplatedowncliptrans[i]);
6589 /////////////////////////////////////////////////////
6590 // Placing Kapton Foil
6591 /////////////////////////////////////////////////////
6592 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6593 0.5*fgkEndCapKaptonFoilWidth,
6594 0.5*fgkEndCapKaptonFoilThickness);
6595 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6596 endcapkaptonfoilshape,
6597 fSSDKaptonFlexMedium);
6598 endcapkaptonfoil->SetLineColor(8);
6599 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6600 0.5*fgkEndCapKaptonFoilWidth
6601 - 0.5*fgkEndCapCoverPlateClipWidth,
6602 0.5*fgkEndCapCoverPlateThickness
6603 - 0.5*fgkEndCapKaptonFoilThickness
6604 - fgkEndCapSideCoverWidth[1]
6605 - fgkEndCapSideCoverThickness);
6606 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6607 /////////////////////////////////////////////////////////////
6608 // Placing Electronic Tubes
6609 /////////////////////////////////////////////////////////////
6610 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6611 - fgkEndCapInterfaceCardBThickness
6612 - 9.*fgkEndCapStripConnectionThickness
6613 - 8.*fgkEndCapCardElectBoardBackThickness,
6614 fgkEndCapKaptonFoilWidth
6615 - fgkEndCapInterfaceCardBThickness
6616 - 9.*fgkEndCapStripConnectionThickness
6617 - 8.*fgkEndCapCardElectBoardBackThickness
6618 - fgkEndCapInterfaceElectBoardCardBThickness};
6619 TGeoVolume* endcapeffectivecables[2];
6620 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6621 fgkEndCapEffectiveCableRadiusMax,
6622 endcapeffectivecableswidth[0],
6623 10,"EndCapEffectiveCables1");
6624 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6625 fgkEndCapEffectiveCableRadiusMax,
6626 endcapeffectivecableswidth[1],
6627 25,"EndCapEffectiveCables2");
6628 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6629 TGeoTranslation* endcapeffectivecablestrans[2];
6630 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6631 - 0.5*endcapeffectivecableswidth[0]
6632 - 0.5*(fgkEndCapCoverPlateWidth[0]
6633 - fgkEndCapCoverPlateWidth[2]
6634 - (kendcapcoverplatesmallholenumber-1)
6635 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6636 + fgkEndCapSideCoverLength[2],
6637 - 0.5*fgkEndCapCoverPlateThickness
6638 - (fgkEndCapCardElectBoardBackWidth[0]
6639 - fgkEndCapInterfaceCardBWidth[0]
6640 - fgkEndCapInterfaceCardBWidth[1]));
6641 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6642 - 0.5*endcapeffectivecableswidth[1]
6643 - 0.5*(fgkEndCapCoverPlateWidth[0]
6644 - fgkEndCapCoverPlateWidth[2]
6645 - (kendcapcoverplatesmallholenumber-1)
6646 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6647 + fgkEndCapSideCoverLength[2],
6648 - 0.5*fgkEndCapCoverPlateThickness
6649 - (fgkEndCapCardElectBoardBackWidth[0]
6650 - fgkEndCapInterfaceCardBWidth[0])
6651 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6652 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6653 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6654 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6655 *endcapeffectivecablesrot);
6656 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6657 *endcapeffectivecablesrot);
6658 // for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6659 // endcapeffectivecablescombitrans[0]);
6660 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6661 endcapeffectivecablescombitrans[1]);
6662 /////////////////////////////////////////////////////////////
6663 // Placing End Cap Cards
6664 /////////////////////////////////////////////////////////////
6665 TGeoVolume** endcapcards = GetEndCapCards();
6666 TGeoRotation* endcapcardsrot[2];
6667 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6668 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6669 TGeoTranslation* endcapcardstrans[2];
6670 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6671 - fgkEndCapCardElectBoardBackLength[0]));
6672 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6673 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6674 TGeoHMatrix* endcapcardsmatrix[2];
6675 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6676 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6677 - fgkEndCapCardJMDConnectorLength[0]
6678 - fgkEndCapInterfaceCardBThickness
6679 - 9.*fgkEndCapStripConnectionThickness
6680 - 8.*fgkEndCapCardElectBoardBackThickness;
6681 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6682 - fgkEndCapCoverPlateLength[0]
6683 + 0.5 * (fgkEndCapCoverPlateLength[3]
6684 + 2.0 * fgkEndCapCoverPlateLength[2]),
6685 - stiffenertransx-fgkEndCapStiffenerWidth
6686 - fgkEndCapCardJMDConnectorLength[0]
6687 - fgkEndCapInterfaceCardBThickness
6688 - 2.0 * fgkEndCapStripConnectionThickness
6689 - 1.5 * fgkEndCapInterfaceCardBThickness
6690 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6691 - fgkEndCapCoverPlateWidth[2]
6692 - (kendcapcoverplatesmallholenumber-1)
6693 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6694 + fgkEndCapKaptonFoilWidth,
6695 0.5*fgkEndCapCoverPlateThickness
6696 - fgkEndCapSideCoverWidth[1]);
6697 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6698 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6699 /////////////////////////////////////////////////////////////
6700 // Deallocating memory
6701 /////////////////////////////////////////////////////////////
6702 delete endcapcoverplaterot;
6703 delete endcapcoverplatecombitrans;
6704 delete endcapcoverplatetrans;
6705 for(Int_t i=0; i<3; i++){
6706 delete endcapsidecovercombitrans[i];
6707 if(i<2) delete endcapsidecoverot[i];
6709 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6710 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6711 delete endcapcardsmatrix[0];
6712 return endcapassembly;
6714 ////////////////////////////////////////////////////////////////////////////////
6715 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6719 const char* volname){
6720 /////////////////////////////////////////////////////////////
6721 // Generating EndCap High Voltage Tubes
6722 /////////////////////////////////////////////////////////////
6723 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6724 Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6726 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6727 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6728 effectiveouteradius,0.5*width);
6729 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6730 effectiveinnertubeshape,
6731 fSSDStiffenerConnectorMedium);
6732 effectiveinnertube->SetLineColor(41);
6733 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6734 effectiveoutertubeshape,
6735 fSSDKaptonChipCableMedium);
6736 effectiveoutertube->SetLineColor(39);
6737 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6738 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6739 effectivemothertube->AddNode(effectiveinnertube,1);
6740 effectivemothertube->AddNode(effectiveoutertube,1);
6741 return effectivemothertube;
6743 ////////////////////////////////////////////////////////////////////////////////
6744 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6745 /////////////////////////////////////////////////////////////
6746 // Generating EndCap Support Layer 5 and Layer 6
6747 /////////////////////////////////////////////////////////////
6748 const Int_t knedges = 5;
6749 ///////////////////////////////////////////////
6750 // Setting the vertices for TGeoXtru Up Volume
6751 ///////////////////////////////////////////////
6752 const Int_t klayernumber = 2;
6753 Double_t xupvertex[klayernumber][knedges+3];
6754 Double_t yupvertex[klayernumber][knedges+3];
6755 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6756 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6757 Double_t middlepsi[klayernumber] = {0.0,0.0};
6758 for(Int_t i=0; i<klayernumber; i++){
6759 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6760 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6761 xupvertex[i][2] = -xupvertex[i][1];
6762 xupvertex[i][3] = -xupvertex[i][0];
6764 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6765 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6766 yupvertex[i][2] = yupvertex[i][1];
6767 yupvertex[i][3] = yupvertex[i][0];
6769 middledgeangle[i] = upedgeangle[i]/knedges;
6770 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6771 for(Int_t j=1; j<knedges; j++){
6772 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6773 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6776 ////////////////////////////////////
6777 // Generating Up TGeoXtru
6778 ////////////////////////////////////
6779 TGeoXtru* upendcapsupportshape[klayernumber];
6780 TGeoVolume* upendcapsupport[klayernumber];
6781 char upendcapsupportname[100];
6782 for(Int_t i=0; i<klayernumber; i++){
6783 upendcapsupportshape[i] = new TGeoXtru(2);
6784 snprintf(upendcapsupportname,100,"UpEndCapSupportPieceLayer%i",i+5);
6785 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6786 upendcapsupportshape[i]->DefineSection(0,0.);
6787 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6788 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
6790 upendcapsupport[i]->SetLineColor(5);
6792 ///////////////////////////////////////////////
6793 // Setting the vertices for TGeoXtru Down Volume
6794 ///////////////////////////////////////////////
6795 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6796 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6797 for(Int_t i=0; i<klayernumber; i++){
6798 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6799 xdownvertex[i][1] = xupvertex[i][0];
6800 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6801 ydownvertex[i][1] = yupvertex[i][0];
6802 for(Int_t j=0; j<knedges; j++){
6803 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6804 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6806 for(Int_t j=0; j<knedges; j++){
6807 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6808 * CosD(middlepsi[i]+j*middledgeangle[i]);
6809 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6810 * SinD(middlepsi[i]+j*middledgeangle[i]);
6813 ////////////////////////////////////
6814 // Generating Down TGeoXtru
6815 ////////////////////////////////////
6816 TGeoXtru* downendcapsupportshape[klayernumber];
6817 TGeoVolume* downendcapsupport[klayernumber];
6818 char downendcapsupportname[100];
6819 for(Int_t i=0; i<klayernumber; i++){
6820 downendcapsupportshape[i] = new TGeoXtru(2);
6821 snprintf(downendcapsupportname,100,"DownEndCapSupportPieceLayer%i",i+5);
6822 downendcapsupportshape[i] = new TGeoXtru(2);
6823 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6825 downendcapsupportshape[i]->DefineSection(0,0.);
6826 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6829 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6830 - fgkEndCapSupportLowWidth[i]);
6831 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6833 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
6834 downendcapsupportshape[i],fSSDSupportRingAl);
6835 downendcapsupport[i]->SetLineColor(5);
6837 ///////////////////////////////////////////////
6838 // Setting TGeoPgon Volume
6839 ///////////////////////////////////////////////
6840 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6841 fgkSSDLay6LadderNumber};
6842 TGeoPgon* endcapsupportmothershape[klayernumber];
6843 TGeoVolume** endcapsupportmother;
6844 endcapsupportmother = new TGeoVolume*[klayernumber];
6845 char endcapsupportmothername[100];
6846 for(Int_t i=0; i<klayernumber; i++){
6847 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6848 snprintf(endcapsupportmothername,100,"EndCapSupportMotherLayer%i",i+5);
6849 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6850 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6851 ydownvertex[i][0],yupvertex[i][1]);
6852 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
6855 ////////////////////////////////////
6856 TGeoRotation** endcapsupportrot[klayernumber];
6857 for(Int_t i=0; i<2; i++){
6858 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6859 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6860 endcapsupportrot[i][j] = new TGeoRotation();
6861 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6862 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6863 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6866 return endcapsupportmother;
6868 ////////////////////////////////////////////////////////////////////////////////
6869 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6870 /////////////////////////////////////////////////////////////
6871 // Setting End Cap Support Layer 5 and 6.
6872 /////////////////////////////////////////////////////////////
6873 const Int_t kendcapcoverplatesmallholenumber = 9;
6874 const Int_t klayernumber = 2;
6875 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6876 fgkSSDLay6LadderNumber};
6877 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6878 360.0/kssdlayladdernumber[1]};
6879 TGeoVolume** endcapsupport = EndCapSupport();
6880 TGeoVolume** endcapassembly = GetEndCapAssembly();
6881 TGeoPgon* endcapsupportshape[klayernumber];
6882 Double_t* radiusmin[klayernumber];
6883 Double_t* radiusmax[klayernumber];
6884 for(Int_t i=0; i<klayernumber; i++){
6885 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6886 radiusmin[i] = endcapsupportshape[i]->GetRmin();
6887 radiusmax[i] = endcapsupportshape[i]->GetRmax();
6889 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6890 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6891 endcapassemblyshape->GetDY(),
6892 endcapassemblyshape->GetDZ()};
6893 ///////////////////////////////////////////////
6894 // Setting TGeoPgon Volume for Mother Container
6895 ///////////////////////////////////////////////
6896 TGeoPgon* endcapsupportsystemshape[klayernumber];
6897 char endcapsupportsystemothername[100];
6898 for(Int_t i=0; i<klayernumber; i++){
6899 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6900 snprintf(endcapsupportsystemothername,100,"EndCapSupportSystemLayer%i",i+5);
6901 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
6902 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
6903 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6904 +2.*endcapassemblycenter[2])
6905 /CosD(0.5*upedgeangle[i]));
6906 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
6907 -(fgkEndCapCoverPlateWidth[1]
6908 - fgkEndCapCoverPlateWidth[0]),
6910 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6911 +2.*endcapassemblycenter[2])
6912 /CosD(0.5*upedgeangle[i]));
6914 fgkEndCapSupportSystem = new TGeoVolume*[4];
6915 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
6916 endcapsupportsystemshape[0],fSSDAir);
6917 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
6918 endcapsupportsystemshape[0],fSSDAir);
6919 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
6920 endcapsupportsystemshape[1],fSSDAir);
6921 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
6922 endcapsupportsystemshape[1],fSSDAir);
6923 ///////////////////////////////////////////////
6924 TGeoTranslation* endcapassemblytrans[klayernumber];
6925 for(Int_t i=0; i<klayernumber; i++)
6926 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
6927 - fgkEndCapSideCoverThickness
6928 + endcapassemblycenter[0],
6929 - 0.5*fgkEndCapCoverPlateThickness
6930 - 2.0*fgkEndCapCoolingTubeRadiusMax
6931 + 2.0*endcapassemblycenter[2]
6932 + 0.5*fgkEndCapSupportLength[i]
6933 / TanD(0.5*upedgeangle[i]),
6934 0.5*(fgkEndCapCoverPlateWidth[0]
6935 - fgkEndCapCoverPlateWidth[2]
6936 - (kendcapcoverplatesmallholenumber-1)
6937 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
6938 TGeoRotation** endcapassemblyrot[klayernumber];
6939 TGeoHMatrix** endcapassemblymatrix[klayernumber];
6940 for(Int_t i=0; i<klayernumber; i++){
6941 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
6942 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
6943 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
6944 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
6945 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
6946 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
6947 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
6948 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6949 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
6950 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
6953 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
6954 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
6955 for(Int_t i=0; i<2*klayernumber; i++){
6956 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
6957 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
6958 endcapassemblymatrix[1][j+2]);
6960 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
6962 /////////////////////////////////////////////////////////////
6963 // Deallocating memory
6964 /////////////////////////////////////////////////////////////
6965 for(Int_t i=0; i<klayernumber; i++){
6966 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
6967 delete endcapassemblyrot[i][j];
6969 delete [] endcapassemblyrot[i];
6970 delete endcapassemblymatrix[i][0];
6971 delete endcapassemblymatrix[i][1];
6973 /////////////////////////////////////////////////////////////
6975 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
6976 /////////////////////////////////////////////////////////////
6977 // Setting End Cap Support + End Cap Assembly of Layer 5.
6978 /////////////////////////////////////////////////////////////
6980 AliError("Can't insert end cap support of layer5, mother is null!\n");
6983 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
6984 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
6985 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
6986 fgkEndCapSupportCenterLay5ITSPosition
6987 + fgkEndCapSupportCenterLay5Position
6988 - fgkEndCapSideCoverLength[2]);
6989 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
6990 fgkEndCapSideCoverLength[2]
6991 - fgkEndCapSupportCenterLay5Position
6992 - fgkEndCapSupportCenterLay5ITSPosition);
6993 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
6994 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
6995 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
6996 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
6997 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
6998 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
6999 /////////////////////////////////////////////////////////////
7000 // Deallocating memory
7001 /////////////////////////////////////////////////////////////
7002 delete endcapsupportsystemrot;
7003 delete endcapsupportsystemITSCentertrans[1];
7005 /////////////////////////////////////////////////////////////
7006 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7007 /////////////////////////////////////////////////////////////
7008 // Setting End Cap Support + End Cap Assembly of Layer 6.
7009 /////////////////////////////////////////////////////////////
7011 AliError("Can't insert end cap support of layer6, mother is null!\n");
7014 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7015 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7016 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7017 fgkEndCapSupportCenterLay6ITSPosition
7018 + fgkEndCapSupportCenterLay6Position
7019 - fgkEndCapSideCoverLength[2]);
7020 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7021 fgkEndCapSideCoverLength[2]
7022 - fgkEndCapSupportCenterLay6Position
7023 - fgkEndCapSupportCenterLay6ITSPosition);
7024 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7025 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7026 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7027 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7028 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7029 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7030 /////////////////////////////////////////////////////////////
7031 // Deallocating memory
7032 /////////////////////////////////////////////////////////////
7033 delete endcapsupportsystemrot;
7034 delete endcapsupportsystemITSCentertrans[1];
7036 ////////////////////////////////////////////////////////////////////////////////
7037 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7038 /////////////////////////////////////////////////////////////
7039 // Setting Ladder Support of Layer 5.
7040 /////////////////////////////////////////////////////////////
7042 AliError("Can't insert ladder lupport of layer5, mother is null!\n");
7045 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7047 TGeoTranslation* centerITSRingSupportLay5trans[2];
7048 for(Int_t i=0; i<2; i++){
7049 centerITSRingSupportLay5trans[i] =
7050 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7051 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7054 ////////////////////////////////////////////////////////////////////////////////
7055 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7056 /////////////////////////////////////////////////////////////
7057 // Setting Ladder Support of Layer 6.
7058 /////////////////////////////////////////////////////////////
7060 AliError("Can't insert ladder lupport of layer6, mother is null!\n");
7063 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7065 TGeoTranslation* centerITSRingSupportLay6trans[2];
7066 for(Int_t i=0; i<2; i++){
7067 centerITSRingSupportLay6trans[i] =
7068 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7069 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7072 ////////////////////////////////////////////////////////////////////////////////
7073 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7074 /////////////////////////////////////////////////////////////
7075 // Setting Ladder Support of Layer 6.
7076 /////////////////////////////////////////////////////////////
7078 AliError("Can't insert SSD Cone, mother is null!\n");
7081 if(!fSSDCone) SetSSDCone();
7082 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7083 + fgkSSDCentralAL3SupportLength);
7084 moth->AddNode(fSSDCone,1,ssdconetrans);
7086 ////////////////////////////////////////////////////////////////////////////////
7087 void AliITSv11GeometrySSD::SetSSDCone(){
7088 /////////////////////////////////////////////////////////////
7089 // Method generating SSDCone
7090 /////////////////////////////////////////////////////////////
7091 if(!fCreateMaterials) CreateMaterials();
7092 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7093 Double_t ssdpconesectionradiusmax[16];
7094 Double_t ssdpconesectionradiusmin[16];
7095 Double_t ssdpconezsection[16];
7096 TGeoPcon* ssdpconelittleholeshape[8];
7097 TGeoVolume* ssdpconelittlehole[8];
7098 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7099 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7100 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7101 / SinD(fgkSSDPConeAngle)
7102 + ssdpconesectionradiusmin[0];
7103 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7104 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7105 / SinD(fgkSSDPConeAngle);
7106 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7107 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7108 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7109 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7110 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7111 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7112 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7113 ssdpconelittlehole[0]->SetLineColor(4);
7114 /////////////////////////////////////////////////////////////
7115 ssdpconezsection[2] = ssdpconezsection[1];
7116 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7117 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7118 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7119 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7120 / SinD(fgkSSDPConeAngle);
7121 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7122 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7123 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7124 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7125 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7126 * TMath::RadToDeg();
7127 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7128 60.-ssdpconelittleholeangle,2);
7129 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7130 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7131 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7132 ssdpconelittlehole[1]->SetLineColor(4);
7133 TGeoRotation* ssdconelittleholerot[6];
7134 for(Int_t i=0; i<6; i++){
7135 ssdconelittleholerot[i] = new TGeoRotation();
7136 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7138 /////////////////////////////////////////////////////////////
7139 ssdpconezsection[4] = ssdpconezsection[3];
7140 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7141 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7142 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7143 * CosD(fgkSSDPConeAngle)
7144 / SinD(fgkSSDPConeAngle);
7145 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7146 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7147 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7148 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7149 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7150 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7151 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7152 ssdpconelittlehole[2]->SetLineColor(4);
7153 ///////////////////////////////////////////////////
7154 ssdpconezsection[6] = ssdpconezsection[5];
7155 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7156 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7157 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7158 -ssdpconezsection[0]
7159 * CosD(fgkSSDPConeAngle)
7160 / SinD(fgkSSDPConeAngle);
7161 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7162 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7163 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7164 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7165 * TMath::RadToDeg();
7166 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7167 45.-ssdpconemiddleholeangle,2);
7168 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7169 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7170 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7171 ssdpconelittlehole[3]->SetLineColor(4);
7172 TGeoRotation* ssdconemiddleholerot[8];
7173 for(Int_t i=0; i<8; i++){
7174 ssdconemiddleholerot[i] = new TGeoRotation();
7175 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7177 /////////////////////////////////////////////////////////////
7178 ssdpconezsection[8] = ssdpconezsection[7];
7179 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7180 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7181 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7182 * CosD(fgkSSDPConeAngle)
7183 / SinD(fgkSSDPConeAngle);
7184 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7185 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7186 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7187 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7188 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7189 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7190 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7191 ssdpconelittlehole[4]->SetLineColor(4);
7192 /////////////////////////////////////////////////////////////
7193 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7194 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7195 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7196 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7197 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7198 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7199 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7200 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7201 * TMath::RadToDeg();
7202 ssdpconezsection[10] = ssdpconezsection[9];
7203 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7204 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7205 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7206 * CosD(fgkSSDPConeAngle)
7207 / SinD(fgkSSDPConeAngle);
7208 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7209 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7210 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7211 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7212 ssdpconetrapezoidsectionangle,2);
7213 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7214 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7215 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7216 ssdpconelittlehole[5]->SetLineColor(4);
7217 TGeoRotation* ssdconeupradiusrot[8];
7218 for(Int_t i=0; i<8; i++){
7219 ssdconeupradiusrot[i] = new TGeoRotation();
7220 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7222 /////////////////////////////////////////////////////////////
7223 ssdpconezsection[12] = ssdpconezsection[11];
7224 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7225 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7226 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7227 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7228 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7229 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7230 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7231 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7232 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7233 ssdpconelittlehole[6]->SetLineColor(4);
7234 /////////////////////////////////////////////////////////////
7235 ssdpconezsection[14] = 0.0;
7236 ssdpconezsection[15] = ssdpconezsection[0];
7237 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7238 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7239 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7240 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7241 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7242 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7243 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7244 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7245 ssdpconelittlehole[7]->SetLineColor(4);
7246 /////////////////////////////////////////////////////////////
7247 TGeoTube* ssdtubeconeshape[2];
7248 TGeoVolume* ssdtubecone[2];
7249 TGeoTranslation* ssdtubeconetrans[2];
7250 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7251 fgkSSDPConeExternalRadius,
7252 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7253 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7254 0.5*ssdpconezsection[0]);
7255 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7256 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7257 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7258 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7259 + ssdpconezsection[13]);
7260 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7261 ssdtubecone[0]->SetLineColor(4);
7262 ssdtubecone[1]->SetLineColor(4);
7263 /////////////////////////////////////////////////////////////
7264 // Mother Volume Container
7265 /////////////////////////////////////////////////////////////
7266 Double_t ssdconemotherradiusmin[8];
7267 Double_t ssdconemotherradiusmax[8];
7268 Double_t ssdconemothersection[8];
7269 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7270 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7271 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7272 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7273 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7274 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7275 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7276 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7277 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7278 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7279 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7280 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7281 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7282 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7283 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7284 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7285 ssdconemothersection[0] = 0.0;
7286 ssdconemothersection[1] = ssdpconezsection[0];
7287 ssdconemothersection[2] = ssdpconezsection[0];
7288 ssdconemothersection[3] = ssdpconezsection[11];
7289 ssdconemothersection[4] = ssdpconezsection[11];
7290 ssdconemothersection[5] = ssdpconezsection[13];
7291 ssdconemothersection[6] = ssdpconezsection[13];
7292 ssdconemothersection[7] = fgkSSDPConeLength;
7293 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7294 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7295 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7296 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7297 /////////////////////////////////////////////////////////////
7298 //Placing the Volumes into Mother
7299 /////////////////////////////////////////////////////////////
7300 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7301 for(Int_t i=0; i<6; i++){
7302 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7304 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7305 for(Int_t i=0; i<8; i++){
7306 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7308 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7309 for(Int_t i=0; i<8; i++){
7310 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7312 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7313 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7314 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7315 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7316 /////////////////////////////////////////////////////////////
7317 // ITS General Support
7318 /////////////////////////////////////////////////////////////
7319 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7320 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7321 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7322 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7323 - fgkSSDCentralAL3SupportLength);
7324 ssdcentralsupport->SetLineColor(4);
7325 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7326 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7327 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7328 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7329 TGeoTranslation* ssdcentralal3supportrans[3];
7330 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7331 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7332 - 1.25*fgkSSDCentralAL3SupportLength);
7333 ssdcentralal3support->SetLineColor(4);
7334 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7335 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7336 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7337 Double_t ssdpconcentralradiusmin[2];
7338 Double_t ssdpconcentralradiusmax[2];
7339 Double_t ssdpconcentralsection[2];
7340 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7341 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7342 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7343 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7344 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7345 ssdpconcentralsection[1] = 0.;
7346 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7347 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7348 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7349 ssdpconcentralal3->SetLineColor(4);
7350 fSSDCone->AddNode(ssdpconcentralal3,1);
7351 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7352 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7353 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7354 -2.*fgkSSDCentralAL3SupportLength);
7355 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7356 *ssdcentralal3supportrot);
7357 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7358 TGeoRotation* ssdconemotherot = new TGeoRotation();
7359 ssdconemotherot->SetAngles(90.,180.,-90.);
7360 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7361 -2.*fgkSSDCentralAL3SupportLength);
7362 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7363 fSSDCone->AddNode(ssdconemother,1);
7364 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7365 /////////////////////////////////////////////////////////////
7366 // Deallocating memory
7367 /////////////////////////////////////////////////////////////
7368 delete ssdcentralal3supportrot;
7369 delete ssdcentralal3supportrans[2];
7370 delete ssdconemotherot;
7371 delete ssdconemothertrans;
7372 /////////////////////////////////////////////////////////////
7374 ////////////////////////////////////////////////////////////////////////////////
7375 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7376 /////////////////////////////////////////////////////////////
7377 // Setting SSD Cables
7378 /////////////////////////////////////////////////////////////
7380 AliError("Can't insert SSD Cables, mother is null!\n");
7383 TGeoVolume* ssdcables = SetSSDCables();
7384 moth->AddNode(ssdcables,1);
7386 ////////////////////////////////////////////////////////////////////////////////
7387 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7388 /////////////////////////////////////////////////////////////
7389 // Method generating SSDCables
7390 /////////////////////////////////////////////////////////////
7392 /////////////////////////////////////////////////////////////////////////////////
7393 // SSD Cables Parameters (lengths are in mm and angles in degrees)
7394 /////////////////////////////////////////////////////////////////////////////////
7396 const Double_t kSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
7397 const Double_t kSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
7399 // Cable thickness for rings at outer Z
7400 // Average: 9/2 = 4.5 cables per quadrant
7401 // Ideally 1/16 * 38(34) cables, but take factor to (1/8) to accomodate kinks and loops (there are only 2 different cable lengths); 21 mm^2 Cu each
7403 const Double_t kSSDCablesLay5RingArea = 21.*34./8.*fgkmm*fgkmm; // to be fixed in order to reproduce material budget
7404 const Double_t kSSDCablesLay6RingArea = 21.*38./8.*fgkmm*fgkmm; // to be fixed in order to reproduce material budget
7407 const Double_t kSSDCablesHeight = 3.2*fgkmm; // 3.2 mm*13 cm width = 18 cables, 185g/m each Add fudge factor of 2 to get to ~25 kg measured
7409 const Double_t kSSDCableAngle = 22.5;
7410 // MvL: remove water?
7411 const Double_t kSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm; // to be fixed in order to reproduce material budget
7412 const Double_t kSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
7413 const Double_t kSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
7414 const Double_t kSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
7415 const Double_t kSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
7416 const Double_t kSSDPatchPanel2RB26Radius = 451.3*fgkmm;
7417 const Double_t kSSDPatchPanel2RB24Radius = 451.3*fgkmm;
7418 const Double_t kSSDPatchPanelHeight = 87.5*fgkmm;
7420 // SSD Layer 5 Cables
7421 //////////////////////////////////////////////////////////////////////////////////////////////////
7422 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7423 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
7424 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
7425 //////////////////////////////////////////////////////////////////////////////////////////////////
7426 // Printf(Form("Cable ring: rad min: %g length %g thick %g", ssdcableslay5rigthsideradiusmin, ssdcablelay5rightsidelength, kSSDCablesLay5RingArea/ssdcablelay5rightsidelength));
7430 ////////////////////////////////////
7431 // Double_t cablescapacity[20];
7432 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7433 ////////////////////////////////////
7434 //ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7435 ////////////////////////////////////
7436 // TGeoPCone Volumes
7437 ///////////////////////////////////
7438 TGeoPcon* ssdcableslay5pconshape[3];
7439 TGeoVolume* ssdcableslay5pcon[3];
7440 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7441 Double_t ssdcableslay5pconzsection[6];
7442 Double_t ssdcableslay5pconrmin[6];
7443 Double_t ssdcableslay5pconrmax[6];
7444 ssdcableslay5pconrmin[0] = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
7445 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7447 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7448 + fgkEndCapSupportCenterLay5Position;
7449 //+ 2.*ssdcablelay5rightsidelength; // removing this generates overlap with the water ring
7450 // Keeping it generates overlap with the cones...
7451 // SSDCables/SSDCableLay5RightSideWaterTube_2 ovlp=0.0939792
7452 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7453 + fgkSSDCentralAL3SupportLength
7454 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7455 * TanD(fgkSSDPConeAngle);
7456 Double_t dz = ssdcableslay5pconzsection[1]-ssdcableslay5pconzsection[0];
7457 Double_t pconethickness = kSSDCablesLay5RingArea/TMath::Abs(dz);
7458 ssdcableslay5pconrmax[0] = ssdcableslay5pconrmin[0]+pconethickness;
7459 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+pconethickness;
7460 //Printf(Form("pcone: r1 %g r2 %g z1 %g z2 %g thickness %g", ssdcableslay5pconrmax[0], ssdcableslay5pconrmax[1],
7461 // ssdcableslay5pconzsection[0],ssdcableslay5pconzsection[1],pconethickness));
7463 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7464 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7465 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7466 ssdcableslay5pconshape[0],fSSDCopper);
7467 ssdcableslay5pcon[0]->SetLineColor(9);
7468 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7470 Double_t totvol = ssdcableslay5pcon[0]->Capacity();
7471 // Printf(Form("Cables, lay5, pCone,volume: %g", ssdcableslay5pcon[0]->Capacity()));
7472 ////////////////////////////////////
7473 // cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7474 ////////////////////////////////////
7477 // PCon 2 and 3 are cables going through/towards holes in supports
7479 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7480 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7481 + fgkSSDCentralAL3SupportLength
7482 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7483 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7484 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7485 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7486 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7487 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7489 // Printf(Form("PCon2, phi %g dphi %g ",90.0-kSSDCableAngle-0.5*ssdcableangle, ssdcableangle));
7490 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7491 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7492 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7493 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7494 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7495 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3] + kSSDCablesHeight;
7496 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7497 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7498 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7499 ssdcableslay5pcon[1]->SetLineColor(9);
7500 ////////////////////////////////////
7501 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7503 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7504 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7505 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7506 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7507 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7508 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7509 * TanD(fgkSSDPConeAngle)
7510 + 0.5*fgkSSDCentralSupportLength
7511 + fgkSSDCentralAL3SupportLength;
7512 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7513 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7514 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7515 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7516 ssdcableslay5pcon[2]->SetLineColor(9);
7517 ////////////////////////////////////
7518 TGeoRotation* ssdcableslay5pconrot[4];
7519 for(Int_t i=0; i<4; i++){
7520 ssdcableslay5pconrot[i] = new TGeoRotation();
7521 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7522 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7523 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
7524 // Printf(Form("Pcon2, Pcon3, vol %g %g",ssdcableslay5pcon[1]->Capacity(),ssdcableslay5pcon[2]->Capacity()));
7525 totvol += ssdcableslay5pcon[1]->Capacity()+ssdcableslay5pcon[2]->Capacity();
7527 ////////////////////////////////////
7528 //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7529 //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7530 ////////////////////////////////////
7531 // Positioning Left SSD Cables Part
7532 ////////////////////////////////////
7533 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7534 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7535 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7536 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7537 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7538 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7539 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7540 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7542 ////////////////////////////////////
7543 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7544 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7545 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7546 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7547 /////////////////////////////////////////////////////////////
7548 // Water Tubes Layer 5
7549 /////////////////////////
7550 /* Remove ring; could be replaced with a PCone next to/on top of the cables
7553 // MvL: Remove ring; put everything in PCone
7555 // Need to keep dimensions for water ring...
7557 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7559 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
7560 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7561 - fgkSSDLowerPConeRadius)
7562 * TanD(fgkSSDPConeAngle);
7563 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7564 + fgkEndCapSupportCenterLay5Position
7565 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7566 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7567 - ssdcableslay5startconedistance;
7568 ssdcablelay5rightsidelength *= ssdcablesfactor;
7569 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+kSSDCablesLay5RingArea/ssdcablelay5rightsidelength;
7572 TGeoTranslation* ssdcablelay5rightrans =
7573 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7574 + fgkEndCapSupportCenterLay5Position
7575 + 0.5*ssdcablelay5rightsidelength);
7577 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7578 - 0.5*ssdcablelay5rightsidelength
7579 - fgkEndCapSupportCenterLay5Position
7580 - fgkEndCapSupportCenterLay5ITSPosition);
7582 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7583 ssdcableslay5rightsideradiusmax
7584 + kSSDCablesLay5RightSideWaterHeight,
7585 0.5*ssdcablelay5rightsidelength);
7586 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7587 ssdcablelay5rightubewatershape,
7588 fSSDCoolingTubeWater);
7589 ssdcablelay5rightwatertube->SetLineColor(7);
7590 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7591 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7593 ////////////////////////////////////
7594 // TGeoPCone Water Volumes Layer
7595 ///////////////////////////////////
7596 TGeoPcon* ssdcableslay5pconwatershape[3];
7597 TGeoVolume* ssdcableslay5pconwater[3];
7598 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7599 Double_t ssdcableslay5pconwaterzsection[6];
7600 Double_t ssdcableslay5pcwateronrmin[6];
7601 Double_t ssdcableslay5pconwaterrmax[6];
7602 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7603 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7604 + kSSDCablesLay5RightSideWaterHeight;
7605 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7606 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7607 + kSSDCablesLay5RightSideWaterHeight;
7608 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7609 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7610 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7611 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7612 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7613 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7614 ssdcableslay5pconwater[0]->SetLineColor(7);
7615 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7616 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7617 ////////////////////////////////////
7618 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7619 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7620 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7622 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7623 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7624 + kSSDCablesLay5RightSideWaterHeight;
7625 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7626 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7627 + kSSDCablesLay5RightSideWaterHeight;
7628 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7629 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7630 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7631 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7632 ssdcableslay5pconwater[1]->SetLineColor(7);
7633 ////////////////////////////////////
7634 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7636 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7637 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7638 + kSSDCablesLay5RightSideWaterHeight;
7639 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7640 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7641 + kSSDCablesLay5RightSideWaterHeight;
7642 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7643 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7644 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7645 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7646 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7647 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7648 ssdcableslay5pconwater[2]->SetLineColor(7);
7649 ////////////////////////////////////
7650 TGeoRotation* ssdcableslay5pconwaterot[4];
7651 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7652 for(Int_t i=0; i<4; i++){
7653 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7654 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7655 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7656 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7657 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7658 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7659 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7660 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7662 /////////////////////////
7663 // SSD Layer 6 Cables
7664 /////////////////////////
7665 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+kSSDCablesLay6TubeRadiusMin;
7666 Double_t ssdcablelay6rightsidelength = 2.; // cm was 2.*ssdcablelay5rightsidelength;
7667 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+kSSDCablesLay6RingArea/ssdcablelay6rightsidelength;
7668 // Printf(Form("Lay 6 cables, length %g, radius %g, thickness %g", ssdcablelay6rightsidelength, ssdcableslay6rigthsideradiusmin, kSSDCablesLay6RingArea/ssdcablelay6rightsidelength));
7669 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7670 ssdcableslay6rightsideradiusmax,
7671 0.5*ssdcablelay6rightsidelength);
7672 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7673 ssdcablelay6rightubeshape,
7675 ssdcablelay6righttube->SetLineColor(9);
7676 TGeoTranslation* ssdcablelay6rightrans =
7677 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7678 + fgkEndCapSupportCenterLay6Position
7679 + 0.5*ssdcablelay6rightsidelength);
7680 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7681 - 0.5*ssdcablelay6rightsidelength
7682 - fgkEndCapSupportCenterLay6Position
7683 - fgkEndCapSupportCenterLay6ITSPosition);
7684 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7685 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7686 // Printf(Form("Cables; ring layer 6, volume: %g",ssdcablelay6rightubeshape->Capacity()));
7687 totvol += ssdcablelay6rightubeshape->Capacity();
7688 ////////////////////////////////////
7689 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7690 ////////////////////////////////////
7691 // MvL: PCon is part of connection to patch panels;
7692 // removed since current volume is too thick; now absorbed in rings+connections
7694 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7696 TGeoVolume* ssdcableslay6pcon;
7697 Double_t ssdcableslay6pconrmin[2];
7698 Double_t ssdcableslay6pconrmax[2];
7699 Double_t ssdcableslay6pconzsection[2];
7700 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7701 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7702 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7703 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7704 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7705 + fgkEndCapSupportCenterLay6Position
7706 + ssdcablelay6rightsidelength;
7707 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7708 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7709 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7711 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7712 ssdcableslay6pconshape,fSSDCopper);
7713 ssdcableslay6pcon->SetLineColor(9);
7714 for(Int_t i=0; i<4; i++){
7715 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7716 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7719 ////////////////////////////////////
7720 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7721 /////////////////////////
7722 // Water Tubes Layer 6
7723 /////////////////////////
7724 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7725 ssdcableslay6rightsideradiusmax
7726 + kSSDCablesLay5RightSideWaterHeight,
7727 0.5*ssdcablelay6rightsidelength);
7728 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7729 ssdcablelay6righwatertubeshape,
7730 fSSDCoolingTubeWater);
7731 ssdcablelay6rightwatertube->SetLineColor(7);
7732 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7733 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7734 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7736 TGeoVolume* ssdcableslay6waterpcon;
7737 Double_t ssdcableslay6waterpconrmin[2];
7738 Double_t ssdcableslay6waterpconrmax[2];
7739 Double_t ssdcableslay6waterpconzsection[2];
7740 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7741 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7742 + kSSDCablesLay5RightSideWaterHeight;
7743 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7744 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7745 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7746 + fgkEndCapSupportCenterLay6Position
7747 + ssdcablelay6rightsidelength;
7748 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7749 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7750 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7751 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7752 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7753 ssdcableslay6waterpcon->SetLineColor(7);
7754 TGeoRotation* ssdcableslay6pconwaterot[4];
7755 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7756 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7757 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7758 for(Int_t i=0; i<4; i++){
7759 ssdcableslay6pconwaterot[i] = new TGeoRotation();
7760 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7761 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7762 * (*ssdcableslay6pconwaterot[i]));
7763 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7764 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7766 ////////////////////////////////////////
7767 // From ITS Ring to Patch Panel3-RB26
7768 ////////////////////////////////////////
7769 Double_t ssdcablepatchpanel3BB26radiusmin[2];
7770 Double_t ssdcablepatchpanel3BB26radiusmax[2];
7771 Double_t ssdcablepatchpanel3RB26zsection[2];
7772 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*kSSDPatchPanelHeight;// +2.8+0.003;//Avoid small overlap with SPDshieldring;
7773 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
7775 ssdcablepatchpanel3BB26radiusmin[1] = kSSDPatchPanel2RB26Radius;
7776 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
7778 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
7779 + fgkSSDCentralAL3SupportLength
7780 + fgkSSDPConeZLength[0];
7781 ssdcablepatchpanel3RB26zsection[1] = kSSDPatchPanel2RB26ITSDistance;
7782 // Printf(Form("RB26 cable length %g",ssdcablepatchpanel3RB26zsection[1]-ssdcablepatchpanel3RB26zsection[0]));
7783 // Printf(Form("Angular range %g",ssdcableangle));
7785 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
7786 new TGeoPcon(90.0-kSSDCablesPatchPanel2RB26Angle[0]
7787 - 0.5*ssdcableangle,ssdcableangle,2);
7788 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7789 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7790 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7791 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7792 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
7793 TGeoRotation* ssdcablepatchpanel3B26rot[4];
7794 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
7795 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
7796 ssdcablepatchpanel3B26rot[1]->SetAngles(kSSDCablesPatchPanel2RB26Angle[0]
7797 + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7798 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
7799 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0 + kSSDCablesPatchPanel2RB26Angle[0]
7800 + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7801 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
7802 // Printf(Form("Cable to patch panels RB26 volume: %g (x4)",ssdcablepatchpanel3RB26pcon->Capacity()));
7803 ////////////////////////////////////
7804 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7805 ////////////////////////////////////////
7806 // ITS Ring Cables RB26 Part
7807 ////////////////////////////////////////
7808 Double_t ssdcableitsring3BB26pconzsection[2];
7809 Double_t ssdcableitsring3BB26pconrmin[2];
7810 Double_t ssdcableitsring3BB26pconrmax[2];
7811 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7812 + fgkSSDCentralAL3SupportLength
7813 + (4.0/5.0)*fgkSSDPConeZLength[0];
7814 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
7815 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
7816 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0] + 2.5*kSSDCablesHeight; // widths of cable bunch is about half of patch panels; need factor 2.5
7818 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7819 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7820 TGeoPcon* ssdcableitsring3BB26pconshape[4];
7821 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0 - kSSDCablesPatchPanel2RB26Angle[0]
7822 - 0.5*ssdcableangle,ssdcableangle
7823 + (kSSDCablesPatchPanel2RB26Angle[0]
7824 - kSSDCableAngle),2);
7825 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0 + kSSDCablesPatchPanel2RB26Angle[1]
7826 - 0.5*ssdcableangle,ssdcableangle
7827 + 3.0*kSSDCableAngle
7828 - kSSDCablesPatchPanel2RB26Angle[1],2);
7829 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-kSSDCablesPatchPanel2RB26Angle[0]
7830 - 0.5*ssdcableangle,ssdcableangle
7832 + kSSDCablesPatchPanel2RB26Angle[0],2);
7833 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+kSSDCablesPatchPanel2RB26Angle[1]
7834 - 0.5*ssdcableangle,ssdcableangle
7835 + 3.0*kSSDCableAngle
7836 - kSSDCablesPatchPanel2RB26Angle[1],2);
7837 for(Int_t i=0;i<4;i++)
7838 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7839 ssdcableitsring3BB26pconrmin[j],
7840 ssdcableitsring3BB26pconrmax[j]);
7841 TGeoVolume* ssdcableitsring3BB26pcon[4];
7842 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7843 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7844 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7845 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7846 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7847 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7848 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7849 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7850 for(Int_t i=0;i<4;i++){
7851 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
7852 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
7853 //Printf(Form("Cable to patch panels RB26 volume part 2: %g (%d)",ssdcableitsring3BB26pcon[i]->Capacity(),i));
7856 ////////////////////////////////////
7857 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7858 // + ssdcableitsring3BB26pconshape[1]->Capacity()
7859 // + ssdcableitsring3BB26pconshape[2]->Capacity()
7860 // + ssdcableitsring3BB26pconshape[3]->Capacity();
7861 ////////////////////////////////////////
7862 // From ITS Ring to Patch Panel2-RB24
7863 ////////////////////////////////////////
7864 Double_t ssdcablepatchpanel3BB24radiusmin[2];
7865 Double_t ssdcablepatchpanel3BB24radiusmax[2];
7866 Double_t ssdcablepatchpanel3RB24zsection[2];
7867 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7868 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
7869 ssdcablepatchpanel3BB24radiusmin[1] = kSSDPatchPanel2RB24Radius;
7870 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
7872 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7873 - fgkSSDCentralAL3SupportLength
7874 - fgkSSDPConeZLength[0];
7875 ssdcablepatchpanel3RB24zsection[1] = -kSSDPatchPanel2RB24ITSDistance;
7876 //Printf(Form("RB24 cable length %g",ssdcablepatchpanel3RB24zsection[1]-ssdcablepatchpanel3RB24zsection[0]));
7877 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
7878 new TGeoPcon(90.0-kSSDCablesPatchPanel2RB24Angle[1]
7879 - 0.5*ssdcableangle,ssdcableangle,2);
7880 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7881 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7882 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7883 ssdcablepatchpanel3RB24pconshape,
7885 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
7886 TGeoRotation* ssdcablepatchpanel3B24rot[4];
7887 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
7888 ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
7889 ssdcablepatchpanel3B24rot[1]->SetAngles(kSSDCablesPatchPanel2RB24Angle[0]
7890 + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7891 ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
7892 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+kSSDCablesPatchPanel2RB24Angle[0]
7893 + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7894 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
7895 //Printf(Form("Cable to patch panels RB24 volume: %g (x4)",ssdcablepatchpanel3RB24pcon->Capacity()));
7896 ////////////////////////////////////
7897 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7898 ////////////////////////////////////////
7899 // ITS Ring Cables RB24 Part
7900 ////////////////////////////////////////
7901 Double_t ssdcableitsring3BB24pconzsection[2];
7902 Double_t ssdcableitsring3BB24pconrmin[2];
7903 Double_t ssdcableitsring3BB24pconrmax[2];
7904 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7905 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
7906 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
7907 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0] + 2.5*kSSDCablesHeight; // Cable bunch width smaller; make it thicker
7909 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
7910 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
7911 TGeoPcon* ssdcableitsring3BB24pconshape[4];
7912 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7913 + (90.0-kSSDCablesPatchPanel2RB24Angle[1]
7914 - kSSDCableAngle),2);
7915 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+kSSDCableAngle-0.5*ssdcableangle,
7916 ssdcableangle-kSSDCableAngle
7917 + kSSDCablesPatchPanel2RB24Angle[0],2);
7918 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7920 + 90.0 - kSSDCablesPatchPanel2RB24Angle[1],2);
7921 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+kSSDCableAngle-0.5*ssdcableangle,
7922 ssdcableangle-kSSDCableAngle
7923 + kSSDCablesPatchPanel2RB24Angle[0],2);
7924 for(Int_t i=0;i<4;i++)
7925 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
7926 ssdcableitsring3BB24pconrmin[j],
7927 ssdcableitsring3BB24pconrmax[j]);
7928 TGeoVolume* ssdcableitsring3BB24pcon[4];
7929 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
7930 ssdcableitsring3BB24pconshape[0],fSSDCopper);
7931 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
7932 ssdcableitsring3BB24pconshape[1],fSSDCopper);
7933 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
7934 ssdcableitsring3BB24pconshape[2],fSSDCopper);
7935 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
7936 ssdcableitsring3BB24pconshape[3],fSSDCopper);
7937 for(Int_t i=0;i<4;i++){
7938 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
7939 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
7940 // Printf(Form("Cable to patch panels RB24 (part 2) volume: %g (%d)",ssdcableitsring3BB24pcon[i]->Capacity(),i));
7943 ////////////////////////////////////
7944 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
7945 // + ssdcableitsring3BB24pconshape[1]->Capacity()
7946 // + ssdcableitsring3BB24pconshape[2]->Capacity()
7947 // + ssdcableitsring3BB24pconshape[3]->Capacity();
7949 // MvL: Pcon are connection to patch panels (part of)
7950 // Removed; do not contribute much; put into ring structure
7952 TGeoPcon* ssdcablelay6materialbudgetpconshape =
7953 new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
7954 TGeoVolume* ssdcablelay6materialbudgetpcon;
7955 Double_t ssdcablelay6materialbudgetpconrmin[2];
7956 Double_t ssdcablelay6materialbudgetpconrmax[2];
7957 Double_t ssdcablelay6materialbudgetpconzsection[2];
7958 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
7959 + kSSDCablesLay5RightSideWaterHeight;
7960 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
7961 + kSSDCableMaterialBudgetHeight;
7962 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
7963 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
7964 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7965 + fgkEndCapSupportCenterLay6Position
7966 + ssdcablelay6rightsidelength;
7967 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7968 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
7969 ssdcablelay6materialbudgetpconzsection[i],
7970 ssdcablelay6materialbudgetpconrmin[i],
7971 ssdcablelay6materialbudgetpconrmax[i]);
7972 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
7973 ssdcablelay6materialbudgetpconshape,fSSDCopper);
7974 ssdcablelay6materialbudgetpcon->SetLineColor(9);
7975 for(Int_t i=0; i<4; i++){
7976 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
7977 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7980 ////////////////////////////////////
7981 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
7982 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
7983 Double_t ssdcablesvolume = 0.0;
7984 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
7985 std::cout << ssdcablesvolume << std::endl;*/
7986 // Printf(Form("Total volume (one side; without conn to patch panel): %g",totvol));
7987 return ssdcablesmother;
7989 ////////////////////////////////////////////////////////////////////////////////
7990 TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3 const * const vertexpos[4] , const Double_t* width,
7991 Double_t height, const char* shapename, Int_t isign) const{
7992 /////////////////////////////////////////////////////////////
7993 // Method generating an Arb shape
7994 /////////////////////////////////////////////////////////////
7995 const Int_t kvertexnumber = 8;
7996 const Int_t ktransvectnumber = 2;
7997 TVector3 vertex[kvertexnumber];
7998 TVector3 transvector[2];
7999 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
8000 /////////////////////////////////////////////////////////////
8001 //Setting the vertices for TGeoArb8
8002 /////////////////////////////////////////////////////////////
8003 vertex[0] = *vertexpos[0];
8004 vertex[1] = *vertexpos[1];
8005 vertex[2] = vertex[1];
8006 vertex[3] = vertex[0];
8007 vertex[4] = *vertexpos[2];
8008 vertex[5] = *vertexpos[3];
8009 vertex[6] = vertex[5];
8010 vertex[7] = vertex[4];
8012 // NB: order of points is clockwise
8014 vertex[2] -= transvector[0];
8015 vertex[3] -= transvector[0];
8016 vertex[6] -= transvector[1];
8017 vertex[7] -= transvector[1];
8020 vertex[0] += transvector[0];
8021 vertex[1] += transvector[0];
8022 vertex[4] += transvector[1];
8023 vertex[5] += transvector[1];
8026 /////////////////////////////////////////////////////////////
8027 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
8028 for(Int_t i = 0; i<kvertexnumber;i++) {
8029 arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
8034 ///////////////////////////////////////////////////////////////////////////////
8035 TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8036 Double_t rmax, Int_t nedges, Double_t height){
8037 /////////////////////////////////////////////////////////////
8038 // Method generating Arc shape
8039 /////////////////////////////////////////////////////////////
8040 const Int_t kvertexnumber = 2*nedges+2;
8041 TGeoXtru* arcshape = new TGeoXtru(2);
8042 TVector3** vertexposition[2];
8043 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8044 Double_t angle = 0.;
8045 for(Int_t i=0; i<nedges+1; i++){
8046 angle = 90.+0.5*phi-i*(phi/nedges);
8047 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle),0);
8048 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle),0);
8050 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8051 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8052 for(Int_t i=0; i<kvertexnumber; i++){
8053 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8054 yvertexpoints[i] = vertexposition[0][i]->Y();
8056 else if(i>=1&&i<nedges+2)
8058 xvertexpoints[i] = vertexposition[1][i-1]->X();
8059 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8063 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8064 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8067 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8068 arcshape->DefineSection(0,-0.5*height);
8069 arcshape->DefineSection(1,0.5*height);
8070 /////////////////////////////////////////////////////////////
8071 // Deallocating memory
8072 /////////////////////////////////////////////////////////////
8073 for(Int_t i=0; i<2; i++){
8074 for(Int_t j=0; j<nedges+1; j++)
8075 delete vertexposition[i][j];
8076 delete [] vertexposition[i];
8078 delete [] xvertexpoints;
8079 delete [] yvertexpoints;
8080 /////////////////////////////////////////////////////////////
8083 ////////////////////////////////////////////////////////////////////////////////
8084 TGeoShape* AliITSv11GeometrySSD::GetScrewShape(const Double_t* radius,const Int_t* edgesnumber,const Double_t* section) const {
8085 ///////////////////////////////////////////////////////////////////////
8086 // Method Generating the Screw Shape
8087 // radius[0]: outer radius
8088 // radius[1]: inner radius
8089 // edgesnumber[0]: outer number of edges
8090 // edgesnumber[1]: inner number of edges
8091 // section[0]: lower section position
8092 // section[1]: higher section position
8093 ///////////////////////////////////////////////////////////////////////
8094 Double_t outradius = radius[0];
8095 Double_t inradius = radius[1];
8096 Int_t outvertexnumber = edgesnumber[0];
8097 Int_t invertexnumber = edgesnumber[1];
8098 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8099 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8100 for(Int_t i=0; i<outvertexnumber; i++){
8101 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8102 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8104 for(Int_t i=0; i<invertexnumber; i++){
8105 xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8106 yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
8108 TGeoXtru* screwshapeout = new TGeoXtru(2);
8109 screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8110 screwshapeout->DefineSection(0,section[0]);
8111 screwshapeout->DefineSection(1,section[1]);
8112 TGeoXtru* screwshapein = new TGeoXtru(2);
8113 screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8114 screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8115 screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8116 TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8117 TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8119 delete [] xscrewvertex;
8120 delete [] yscrewvertex;
8123 ////////////////////////////////////////////////////////////////////////////////
8124 TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, const Double_t *section) const {
8125 ///////////////////////////////////////////////////////////////////////
8126 // Method Generating the Hole Shape
8127 // radius of the Hole
8128 // nedges: number of edges to approximate the circle
8129 ///////////////////////////////////////////////////////////////////////
8130 Double_t* xholevertex = new Double_t[nedges];
8131 Double_t* yholevertex = new Double_t[nedges];
8132 Double_t z = 0.5*(section[0]+section[1]);
8133 Double_t dz = 0.5*(section[1]-section[0]);
8134 TGeoTranslation *tr = 0;
8135 if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8136 tr = new TGeoTranslation(0.,0.,z);
8137 tr->RegisterYourself();
8139 TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8140 for(Int_t i=0; i<nedges; i++){
8141 xholevertex[i] = radius*CosD(i*360./nedges);
8142 yholevertex[i] = radius*SinD(i*360./nedges);
8144 TGeoXtru* holeshapeout = new TGeoXtru(2);
8145 holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8146 holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8147 holeshapeout->DefineSection(1,section[1]+0.01);
8148 TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8149 TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8151 delete [] xholevertex;
8152 delete [] yholevertex;
8155 ////////////////////////////////////////////////////////////////////////////////
8156 TVector3* AliITSv11GeometrySSD::GetReflection(const TVector3* vector,const Double_t* param) const{
8157 /////////////////////////////////////////////////////////////
8158 // Given an axis specified by param, it gives the reflection of the point
8159 // respect to the axis
8160 /////////////////////////////////////////////////////////////
8161 TVector3* n = new TVector3(param[0],param[1],param[2]);
8162 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8163 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
8164 /////////////////////////////////////////////////////////////
8165 // Deallocating memory
8166 /////////////////////////////////////////////////////////////
8168 /////////////////////////////////////////////////////////////
8169 return reflectedvector;
8171 ////////////////////////////////////////////////////////////////////////////////
8172 TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(const TGeoHMatrix* ct,
8176 /////////////////////////////////////////////////////////////
8177 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
8178 /////////////////////////////////////////////////////////////
8179 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8180 const Double_t *vect = hmatrix->GetTranslation();
8181 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
8182 hmatrix->SetTranslation(newvect);
8183 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8187 ////////////////////////////////////////////////////////////////////////////////
8188 TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
8189 /////////////////////////////////////////////////////////////
8190 // Method returning the Medium type
8191 /////////////////////////////////////////////////////////////
8193 snprintf(ch,100, "ITS_%s",mediumName);
8194 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8196 AliError(Form("medium %s not found !\n", mediumName));
8199 ////////////////////////////////////////////////////////////////////////////////
8200 void AliITSv11GeometrySSD::CreateMaterials(){
8201 ///////////////////////////////////
8202 // This part has to be modified
8203 ///////////////////////////////////
8204 ///////////////////////////////////
8205 // Silicon for Sensor
8206 ///////////////////////////////////
8207 fSSDSensorMedium = GetMedium("SI$");
8208 ///////////////////////////////////
8209 // Silicon Mixture for Sensor
8210 ///////////////////////////////////
8211 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8212 fSSDChipGlueMedium = GetMedium("EPOXY$");
8213 ///////////////////////////////////
8214 // Stiffener Components Materials
8215 ///////////////////////////////////
8216 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
8217 ///////////////////////////
8218 // Stiffener Connectors
8219 ///////////////////////////
8220 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
8221 ////////////////////////////////
8222 // Stiffener 0603-1812 Capacitor
8223 ////////////////////////////////
8224 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8225 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8226 fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$");
8227 ///////////////////////////
8228 // Stiffener Hybrid Wire
8229 ///////////////////////////
8230 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
8231 ///////////////////////////
8232 // Al for Cooling Block
8233 ///////////////////////////
8234 fSSDAlCoolBlockMedium = GetMedium("AL$");
8235 //////////////////////////////////////////////////////
8236 // Kapton and Al for Chip Cable Flex and Ladder Cables
8237 //////////////////////////////////////////////////////
8238 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8239 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8240 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8241 fSSDAlTraceFlexMedium = GetMedium("AL$");
8242 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8243 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
8244 /////////////////////////////////////////////////////////////////
8245 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8246 //////////////////////////////////////////////////////////////////
8247 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
8248 /////////////////////////////////////////////////////////////////
8249 // G10 for Detector Leg, TubeHolder
8250 //////////////////////////////////////////////////////////////////
8251 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8252 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8253 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8254 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8255 /////////////////////////////////////////////////////////////////
8256 // Water and Phynox for Cooling Tube
8257 //////////////////////////////////////////////////////////////////
8258 fSSDCoolingTubeWater = GetMedium("WATER$");
8259 fSSDCoolingTubePhynox = GetMedium("INOX$");
8260 /////////////////////////////////////////////////////////////////////
8261 // Material for Support Rings
8262 /////////////////////////////////////////////////////////////////////
8263 fSSDSupportRingAl = GetMedium("AL$");
8264 fSSDRohaCellCone = GetMedium("ROHACELL$");
8265 /////////////////////////////////////////////////////////////////////
8266 fSSDAir = GetMedium("SDD AIR$");
8267 fSSDCopper = GetMedium("COPPER$");
8268 fSSDSn = GetMedium("Sn$");
8269 fCreateMaterials = kTRUE;
8271 /////////////////////////////////////////////////////////////////////