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::fgSSDsensitiveVolName5 = "ITSssdSensitivL5";
46 const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "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 = 625.0*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;
526 /////////////////////////////////////////////////////////////////////////////////
527 // SSD Cables Parameters (lengths are in mm and angles in degrees)
528 /////////////////////////////////////////////////////////////////////////////////
529 const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
530 const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
531 const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
532 const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
533 const Double_t AliITSv11GeometrySSD::fgkSSDCableAngle = 22.5;
534 const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm; // to be fixed in order to reproduce material budget
535 const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
536 const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
537 const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
538 const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
539 const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = 451.3*fgkmm;
540 const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = 451.3*fgkmm;
541 const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeight = 87.5*fgkmm;
542 const Double_t AliITSv11GeometrySSD::fgkSSDCableMaterialBudgetHeight = 20.0*fgkmm;
543 //const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = fgkSSDPConeExternalRadius;
544 //const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = fgkSSDPConeExternalRadius;
545 /////////////////////////////////////////////////////////////////////////////////
546 ClassImp(AliITSv11GeometrySSD)
547 /////////////////////////////////////////////////////////////////////////////////
548 AliITSv11GeometrySSD::AliITSv11GeometrySSD():
551 fSSDChipGlueMedium(),
552 fSSDStiffenerMedium(),
553 fSSDStiffenerConnectorMedium(),
554 fSSDStiffener0603CapacitorMedium(),
555 fSSDStiffener1812CapacitorMedium(),
556 fSSDStiffenerCapacitorCapMedium(),
557 fSSDStiffenerHybridWireMedium(),
558 fSSDKaptonFlexMedium(),
559 fSSDAlTraceFlexMedium(),
560 fSSDAlTraceLadderCableMedium(),
561 fSSDKaptonLadderCableMedium(),
562 fSSDKaptonChipCableMedium(),
563 fSSDAlTraceChipCableMedium(),
564 fSSDAlCoolBlockMedium(),
566 fSSDSensorSupportMedium(),
567 fSSDCarbonFiberMedium(),
568 fSSDTubeHolderMedium(),
569 fSSDCoolingTubeWater(),
570 fSSDCoolingTubePhynox(),
572 fSSDMountingBlockMedium(),
577 fCreateMaterials(kFALSE),
578 fTransformationMatrices(kFALSE),
579 fBasicObjects(kFALSE),
580 fcarbonfiberjunction(),
581 fcoolingtubesupport(),
583 fssdcoolingblocksystem(),
584 fcoolingblocksystematrix(),
588 fendladdercoolingtubesupportmatrix(),
589 fendladdermountingblock(),
590 fendladdermountingblockclip(),
596 fLay5LadderSupportRing(),
597 fLay6LadderSupportRing(),
598 fgkEndCapSupportSystem(),
600 fColorCarbonFiber(4),
613 ////////////////////////
614 // Standard constructor
615 ////////////////////////
617 /////////////////////////////////////////////////////////////////////////////////
618 AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
619 AliITSv11Geometry(s.GetDebug()),
620 fSSDChipMedium(s.fSSDChipMedium),
621 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
622 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
623 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
624 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
625 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
626 fSSDStiffenerCapacitorCapMedium(s.fSSDStiffenerCapacitorCapMedium),
627 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
628 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
629 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
630 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
631 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
632 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
633 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
634 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
635 fSSDSensorMedium(s.fSSDSensorMedium),
636 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
637 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
638 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
639 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
640 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
641 fSSDSupportRingAl(s.fSSDSupportRingAl),
642 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
643 fSSDRohaCellCone(s.fSSDRohaCellCone),
645 fSSDCopper(s.fSSDCopper),
647 fCreateMaterials(s.fCreateMaterials),
648 fTransformationMatrices(s.fTransformationMatrices),
649 fBasicObjects(s.fBasicObjects),
650 fcarbonfiberjunction(s.fcarbonfiberjunction),
651 fcoolingtubesupport(s.fcoolingtubesupport),
652 fhybridmatrix(s.fhybridmatrix),
653 fssdcoolingblocksystem(s.fssdcoolingblocksystem),
654 fcoolingblocksystematrix(s.fcoolingblocksystematrix),
655 fssdstiffenerflex(s.fssdstiffenerflex),
656 fssdendflex(s.fssdendflex),
657 fcoolingtube(s.fcoolingtube),
658 fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
659 fendladdermountingblock(s.fendladdermountingblock),
660 fendladdermountingblockclip(s.fendladdermountingblockclip),
661 fSSDSensor5(s.fSSDSensor5),
662 fSSDSensor6(s.fSSDSensor6),
663 fSSDLayer5(s.fSSDLayer5),
664 fSSDLayer6(s.fSSDLayer6),
665 fMotherVol(s.fMotherVol),
666 fLay5LadderSupportRing(s.fLay5LadderSupportRing),
667 fLay6LadderSupportRing(s.fLay6LadderSupportRing),
668 fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
669 fSSDCone(s.fSSDCone),
670 fColorCarbonFiber(s.fColorCarbonFiber),
671 fColorRyton(s.fColorRyton),
672 fColorPhynox(s.fColorPhynox),
673 fColorSilicon(s.fColorSilicon),
674 fColorAl(s.fColorAl),
675 fColorNiSn(s.fColorNiSn),
676 fColorKapton(s.fColorKapton),
677 fColorPolyhamide(s.fColorPolyhamide),
678 fColorStiffener(s.fColorStiffener),
679 fColorEpoxy(s.fColorEpoxy),
680 fColorWater(s.fColorWater),
681 fColorG10(s.fColorG10)
683 ////////////////////////
685 ////////////////////////
687 /////////////////////////////////////////////////////////////////////////////////
688 AliITSv11GeometrySSD& AliITSv11GeometrySSD::
689 operator=(const AliITSv11GeometrySSD &s){
690 ////////////////////////
691 // Assignment operator
692 ////////////////////////
693 this->~AliITSv11GeometrySSD();
694 new(this) AliITSv11GeometrySSD(s);
697 if(&s == this) return *this;
698 fMotherVol = s.fMotherVol;
702 ///////////////////////////////////////////////////////////////////////////////
703 void AliITSv11GeometrySSD::CreateTransformationMatrices(){
704 ///////////////////////////////////////////////////////////////////////
705 // Method generating the trasformation matrix for the whole SSD Geometry
706 ///////////////////////////////////////////////////////////////////////
707 // Setting some variables for Carbon Fiber Supportmatrix creation
708 //////////////////////////////////////////////////////////////////////
709 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
710 * CosD(fgkCarbonFiberJunctionAngle[0]);
711 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
712 + fgkCarbonFiberSupportTopEdgeDist[0]
713 + fgkCarbonFiberSupportWidth);
714 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
715 * TanD(fgkCarbonFiberJunctionAngle[0]);
716 TGeoRotation* carbonfiberot[3];
717 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
718 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
719 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
720 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
721 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
722 * CosD(fgkCarbonFiberTriangleAngle),0.,
723 - fgkCarbonFiberTriangleLength
724 * SinD(fgkCarbonFiberTriangleAngle)};
725 ///////////////////////////////////////////
726 //Setting Local Translations and Rotations:
727 ///////////////////////////////////////////
728 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
729 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
730 0.5*carbonfibersupportheight,NULL);
731 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
732 2.*symmetryplaneposition+transvector[1],
733 transvector[2], carbonfiberot[2]);
734 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
735 /////////////////////////////////////////////////////////////
736 // Carbon Fiber Support Transformations
737 /////////////////////////////////////////////////////////////
738 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
739 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
740 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
741 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
742 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
744 /////////////////////////////////////////////////////////////
745 // Carbon Fiber Junction Transformation
746 /////////////////////////////////////////////////////////////
747 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
748 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
749 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
750 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
751 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
752 localcarbonfiberjunctionmatrix[i] =
753 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
754 localcarbonfiberjunctionrot[i] =
755 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
756 localcarbonfiberjunctiontrans[i] =
757 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
759 ///////////////////////
760 // Setting Translations
761 ///////////////////////
762 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
763 localcarbonfiberjunctiontrans[1][0] =
764 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
765 localcarbonfiberjunctiontrans[2][0] =
766 new TGeoTranslation(fgkCarbonFiberTriangleLength
767 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
768 fgkCarbonFiberTriangleLength
769 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
770 localcarbonfiberjunctiontrans[0][1] =
771 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
772 localcarbonfiberjunctiontrans[1][1] =
773 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
774 localcarbonfiberjunctiontrans[2][1] =
775 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
779 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
780 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
781 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
782 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
783 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
784 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
785 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
786 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
787 ////////////////////////////////////////
788 // Setting Carbon Fiber Junction matrix
789 ////////////////////////////////////////
790 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
791 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
792 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
793 localcarbonfiberjunctionmatrix[i][j] =
794 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
795 *localcarbonfiberjunctionrot[i][j]);
796 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
799 /////////////////////////////////////////////////////////////
800 // Carbon Fiber Lower Support Transformations
801 /////////////////////////////////////////////////////////////
802 TGeoTranslation* localcarbonfiberlowersupportrans[2];
803 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
804 fgkCarbonFiberLowerSupportVolumePosition[1]
805 + fgkCarbonFiberLowerSupportVolumePosition[0],
807 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
808 fgkCarbonFiberJunctionWidth
809 - fgkCarbonFiberLowerSupportWidth
810 - fgkCarbonFiberLowerSupportVolumePosition[0]
811 - fgkCarbonFiberLowerSupportVolumePosition[1],
812 - 0.5*fgkCarbonFiberLowerSupportHeight);
813 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
814 fcarbonfiberlowersupportrans[0] =
815 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
816 fcarbonfiberlowersupportrans[1] =
817 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
818 /////////////////////////////////////////////////////////////
819 // SSD Sensor Support Transformations
820 /////////////////////////////////////////////////////////////
821 const Int_t kssdsensorsupportmatrixnumber = 3;
822 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
823 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
824 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
825 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
826 localssdsensorsupportmatrix[i] =
827 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
828 localssdsensorsupportrot[i] =
829 new TGeoRotation*[kssdsensorsupportmatrixnumber];
830 localssdsensorsupportrans[i] =
831 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
833 ///////////////////////
834 // Setting Translations
835 ///////////////////////
836 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
837 0.5*fgkSSDSensorSideSupportWidth,
839 localssdsensorsupportrans[1][0] =
840 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
841 localssdsensorsupportrans[2][0] =
842 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
843 localssdsensorsupportrans[0][1] =
844 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
845 0.5*fgkSSDSensorSideSupportThickness[0],
847 localssdsensorsupportrans[1][1] =
848 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
849 - 0.5*fgkSSDSensorSideSupportThickness[0]
850 - fgkSSDModuleSensorSupportDistance,
852 localssdsensorsupportrans[2][1] =
853 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
854 - fgkSSDSensorCenterSupportPosition,
855 0.5*fgkSSDSensorCenterSupportWidth
856 - 0.5*fgkSSDModuleSensorSupportDistance,
857 fgkSSDSensorCenterSupportThickness[0]);
858 localssdsensorsupportrans[0][2] =
859 new TGeoTranslation(fgkCarbonFiberTriangleLength
860 + fgkCarbonFiberJunctionToSensorSupport,
861 fgkCarbonFiberJunctionWidth
862 - 0.5*(fgkCarbonFiberLowerSupportWidth
863 + fgkSSDSensorCenterSupportLength
864 - fgkSSDSensorCenterSupportThickness[0])
865 - fgkSSDSensorCenterSupportPosition,
867 localssdsensorsupportrans[1][2] =
868 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
869 localssdsensorsupportrans[2][2] =
870 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
874 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
875 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
876 localssdsensorsupportrot[i][j] = new TGeoRotation();
877 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
878 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
879 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
881 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
882 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
883 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
884 ////////////////////////////////////////
885 // SSD Sensor Support matrix
886 ////////////////////////////////////////
887 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
888 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
889 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
890 localssdsensorsupportmatrix[i][j] =
891 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
892 *localssdsensorsupportrot[i][j]);
893 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
896 /////////////////////////////////////////////////////////////
897 // SSD Cooling Tube Support Transformations
898 /////////////////////////////////////////////////////////////
899 const Int_t kcoolingtubesupportmatrixnumber = 2;
900 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
901 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
902 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
903 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
904 /fgkCoolingTubeSupportRmax);
905 localcoolingtubesupportrans[0] =
906 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
907 + 2.*(fgkCoolingTubeSupportLength
908 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
909 + fgkCarbonFiberTriangleLength
910 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
911 localcoolingtubesupportrans[1] =
912 new TGeoTranslation(fgkCarbonFiberJunctionLength
913 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
914 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
915 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
916 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
917 - 0.5*(fgkCarbonFiberLowerSupportWidth
918 + fgkSSDSensorCenterSupportLength
919 - fgkSSDSensorCenterSupportThickness[0])
920 + 0.5*fgkSSDSensorLength,
921 - 0.5*fgkCoolingTubeSupportHeight);
922 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
923 localcoolingtubesupportrot[i] = new TGeoRotation();
924 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
925 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
926 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
927 localcoolingtubesupportmatrix[i] =
928 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
929 *localcoolingtubesupportrot[i]);
930 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
931 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
932 (*localcoolingtubesupportmatrix[0]));
933 /////////////////////////////////////////////////////////////
934 // End Ladder SSD Cooling Tube Support Transformations
935 /////////////////////////////////////////////////////////////
936 TGeoTranslation** localendladdercooltubetrans[2];
937 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
938 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
939 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
940 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
941 - (fgkCoolingTubeSupportLength
942 - fgkCoolingTubeSupportRmax),
943 fgkEndLadderMountingBlockPosition[0]
944 - fgkendladdercoolingsupportdistance[0]
945 + 0.5*fgkCoolingTubeSupportWidth,
946 - 0.5*fgkCoolingTubeSupportHeight);
947 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
948 - (fgkCoolingTubeSupportLength
949 - fgkCoolingTubeSupportRmax),
950 fgkEndLadderMountingBlockPosition[0]
951 + fgkendladdercoolingsupportdistance[1]
952 + 0.5*fgkCoolingTubeSupportWidth,
953 - 0.5*fgkCoolingTubeSupportHeight);
954 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
955 - fgkCoolingTubeSupportRmax)
956 + fgkCarbonFiberTriangleLength
957 - 2.0*fgkCarbonFiberJunctionLength,
960 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
961 fgkendladdercoolingsupportdistance[0]
962 + fgkendladdercoolingsupportdistance[1],
964 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
965 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
966 + fgkCarbonFiberJunctionLength
967 - fgkCoolingTubeSupportLength,
968 fgkEndLadderCarbonFiberLowerJunctionLength[1]
969 - 0.5*fgkCoolingTubeSupportWidth
970 -fgkendladdercoolingsupportdistance[2],
971 - 0.5*fgkCoolingTubeSupportHeight);
972 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
973 + fgkCoolingTubeSupportLength
974 - fgkCoolingTubeSupportRmax
975 - fgkCarbonFiberJunctionLength,
976 fgkEndLadderCarbonFiberLowerJunctionLength[1]
977 - 0.5*fgkCoolingTubeSupportWidth
978 - fgkendladdercoolingsupportdistance[2],
979 - 0.5*fgkCoolingTubeSupportHeight);
980 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
981 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
982 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
983 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
984 (*localcoolingtubesupportrot[1]));
985 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
986 (*localcoolingtubesupportrot[1]));
987 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
988 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
989 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
990 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
991 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
993 fendladdercoolingtubesupportmatrix[1][0] =
994 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
995 *(*localcoolingtubesupportrot[1]));
996 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
997 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
998 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
999 /////////////////////////////////////////////////////////////
1000 // SSD Cooling Tube Transformations
1001 /////////////////////////////////////////////////////////////
1002 TGeoRotation* localcoolingtuberot = new TGeoRotation();
1003 localcoolingtuberot->SetAngles(0.,90.,0.);
1004 TGeoTranslation* localcoolingtubetrans[2];
1005 TVector3* localcoolingtubevect[2];
1007 localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
1008 -fgkCarbonFiberTriangleLength),
1009 fgkCarbonFiberJunctionWidth // Y-coord is local Z, from sensor translation
1010 - fgkCarbonFiberLowerSupportWidth
1011 - fgkLowerSupportToSensorZ ,
1012 - 0.5*fgkCoolingTubeSupportHeight);
1013 localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
1014 localcoolingtubevect[0]->Y(),
1015 localcoolingtubevect[0]->Z());
1016 for(Int_t j=0; j<2; j++){
1017 localcoolingtubetrans[j] =
1018 new TGeoTranslation(localcoolingtubevect[j]->X(),
1019 localcoolingtubevect[j]->Y(),
1020 localcoolingtubevect[j]->Z());
1021 fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j])
1022 *(*localcoolingtuberot));
1024 /////////////////////////////////////////////////////////////
1025 // SSD End Ladder Cooling Tube Transformations
1026 /////////////////////////////////////////////////////////////
1027 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1028 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1029 TGeoTranslation** localendlladdercoolingtubetrans[2];
1030 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
1031 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
1032 for(Int_t i=0; i<2; i++)
1033 for(Int_t j=0; j<2; j++)
1034 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1036 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
1037 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1038 - fgkCoolingTubeSupportRmax)
1039 + fgkCarbonFiberJunctionLength,
1040 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
1041 - 0.5*fgkCoolingTubeSupportHeight);
1042 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1043 - fgkCoolingTubeSupportRmax)
1044 - fgkCarbonFiberJunctionLength
1045 + fgkCarbonFiberTriangleLength,
1046 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
1047 - 0.5*fgkCoolingTubeSupportHeight);
1049 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1050 - fgkCoolingTubeSupportRmax)
1051 + fgkCarbonFiberJunctionLength,
1052 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
1053 - 0.5*fgkCoolingTubeSupportHeight);
1054 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1055 - fgkCoolingTubeSupportRmax)
1056 - fgkCarbonFiberJunctionLength
1057 + fgkCarbonFiberTriangleLength,
1058 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
1059 - 0.5*fgkCoolingTubeSupportHeight);
1060 for(Int_t i=0; i<2; i++)
1061 for(Int_t j=0; j<2; j++){
1062 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1063 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1065 /////////////////////////////////////////////////////////////
1066 // SSD Hybrid Components Transformations
1067 /////////////////////////////////////////////////////////////
1068 const Int_t khybridmatrixnumber = 3;
1069 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1070 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1071 0.5*fgkSSDStiffenerWidth,
1072 0.5*fgkSSDStiffenerHeight);
1073 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1074 fgkSSDModuleStiffenerPosition[1],0.0);
1076 localhybridtrans[2] = new TGeoTranslation(
1077 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1078 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1079 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1080 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1081 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1082 - fgkSSDSensorCenterSupportThickness[0]),
1083 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1084 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
1085 - fgkSSDModuleVerticalDisalignment));
1086 fhybridmatrix = new TGeoHMatrix();
1087 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1088 /////////////////////////////////////////////////////////////
1089 // SSD Cooling Block Transformations
1090 /////////////////////////////////////////////////////////////
1091 TGeoTranslation localcoolingblocktrans (fcoolingtubematrix[0]->GetTranslation()[0]
1092 - 0.5*fgkSSDCoolingBlockLength,
1093 fhybridmatrix->GetTranslation()[1]-0.5*fgkSSDStiffenerWidth,
1094 fhybridmatrix->GetTranslation()[2]+0.5*fgkSSDStiffenerHeight+
1095 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1096 fcoolingblocksystematrix = new TGeoHMatrix(localcoolingblocktrans);
1097 /////////////////////////////////////////////////////////////
1098 // SSD Stiffener Flex Transformations
1099 /////////////////////////////////////////////////////////////
1100 const Int_t klocalflexmatrixnumber = 4;
1101 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1102 for(Int_t i=0; i<fgkflexnumber; i++)
1103 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1104 for(Int_t i=0; i<fgkflexnumber; i++)
1105 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1106 localflexmatrix[i][j] = new TGeoCombiTrans();
1107 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1108 - 2.*fgkSSDModuleStiffenerPosition[1]
1109 - fgkSSDStiffenerWidth;
1110 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1111 +0.5*fgkSSDStiffenerLength,
1112 0.5*fgkSSDStiffenerWidth,
1113 -0.5*fgkSSDStiffenerHeight
1114 -0.5*fgkSSDFlexHeight[0]);
1115 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1116 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1117 -0.5*fgkSSDStiffenerWidth,
1118 -0.5*fgkSSDStiffenerHeight
1119 -0.5*fgkSSDFlexHeight[0]);
1120 TGeoRotation* localflexrot = new TGeoRotation();
1121 localflexrot->SetAngles(180.,0.,0.);
1122 localflexmatrix[1][0]->SetRotation(localflexrot);
1123 for(Int_t i=0; i<fgkflexnumber; i++)
1124 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1125 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1126 for(Int_t i=0; i<fgkflexnumber; i++){
1127 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1128 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1129 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
1131 /////////////////////////////////////////////////////////////
1132 // SSD End Flex Transformations
1133 /////////////////////////////////////////////////////////////
1134 TGeoRotation* localendflexrot = new TGeoRotation();
1135 localendflexrot->SetAngles(0.0,90.0,0.0);
1136 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1137 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1138 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1139 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1140 * TMath::DegToRad()*ssdflexradiusmax
1141 - fgkSSDFlexLength[2]-TMath::Pi()
1142 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1143 - 0.1*fgkSSDFlexFullLength;
1144 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1145 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1146 + fgkSSDFlexLength[2];
1147 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1148 0.5*fgkSSDFlexWidth[0],
1149 2.*fgkSSDStiffenerHeight
1150 + 0.5*fgkSSDFlexHeight[0]);
1151 localendflexmatrix->SetRotation(localendflexrot);
1152 for(Int_t i=0; i<fgkflexnumber; i++)
1153 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1154 /////////////////////////////////////////////////////////////
1155 // End Ladder Carbon Fiber Junction
1156 /////////////////////////////////////////////////////////////
1157 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1158 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1159 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1160 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1161 localendladdercarbonfiberjunctionmatrix[i]
1162 = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1163 localendladdercarbonfiberjunctionrot[i]
1164 = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1165 localendladdercarbonfiberjunctiontrans[i]
1166 = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1167 fendladdercarbonfiberjunctionmatrix[i]
1168 = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
1170 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1171 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1172 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1173 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1175 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1176 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1177 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1178 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1179 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1181 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1182 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1183 * SinD(fgkCarbonFiberTriangleAngle),
1184 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1185 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1187 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1188 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1189 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1190 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1191 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1192 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1193 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1194 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1195 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1196 localendladdercarbonfiberjunctionglobalmatrix[i] =
1197 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1198 *localendladdercarbonfiberjunctionglobalrot[i]);
1200 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1201 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1202 localendladdercarbonfiberjunctionmatrix[i][j] =
1203 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1204 *localendladdercarbonfiberjunctionrot[i][j]);
1205 fendladdercarbonfiberjunctionmatrix[i][j] =
1206 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1207 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1209 /////////////////////////////////////////////////////////////
1210 // End Ladder Carbon Fiber Support
1211 /////////////////////////////////////////////////////////////
1212 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1213 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1214 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1215 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1216 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1217 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1219 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1220 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1221 fendladdercarbonfibermatrix[i][j] =
1222 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1223 *(*fcarbonfibersupportmatrix[j]));
1224 /////////////////////////////////////////////////////////////
1225 // End Ladder SSD Mounting Block
1226 /////////////////////////////////////////////////////////////
1227 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1228 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1229 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1230 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
1231 + fgkSSDMountingBlockLength[1])
1232 + 0.5*fgkCarbonFiberTriangleLength,
1233 fgkEndLadderMountingBlockPosition[i],
1234 - fgkSSDMountingBlockHeight[1]
1235 + 0.5*fgkSSDMountingBlockHeight[0]);
1236 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1237 endladdermountingblockrot->SetAngles(0.,90.,0.);
1238 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1239 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1240 /////////////////////////////////////////////////////////////
1241 // End Ladder SSD Mounting Block Clip Matrix
1242 /////////////////////////////////////////////////////////////
1243 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1244 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1246 TGeoRotation* localendladdercliprot = new TGeoRotation();
1247 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1248 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1249 - fgkSSDMountingBlockLength[1])
1250 + fgkSSDMountingBlockLength[0],0.,0.);
1251 localendladdercliprot->SetAngles(90.,180.,-90.);
1252 TGeoCombiTrans* localendladderclipcombitrans =
1253 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1254 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1255 for(Int_t j=0; j<2; j++){
1256 fendladdermountingblockclipmatrix[i][j] =
1257 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1258 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1260 /////////////////////////////////////////////////////////////
1261 // End Ladder Carbon Fiber Lower Support
1262 /////////////////////////////////////////////////////////////
1263 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1264 fendladderlowersupptrans[i] =
1265 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1266 + 0.5*fgkSSDMountingBlockWidth),
1267 - 0.5*fgkCarbonFiberLowerSupportHeight);
1268 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1269 fgkCarbonFiberLowerSupportVolumePosition[1]
1270 + fgkCarbonFiberLowerSupportVolumePosition[0],
1272 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1273 /////////////////////////////////////////////////////////////
1274 // Matrix for positioning Ladder into mother volume
1275 /////////////////////////////////////////////////////////////
1276 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1277 for(Int_t i=0; i<fgkladdernumber; i++)
1278 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1279 TGeoRotation* localladdermotherrot = new TGeoRotation();
1280 localladdermotherrot->SetAngles(0.,90.,0.);
1281 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1282 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1283 for(Int_t i=0; i<fgkladdernumber; i++){
1284 localladdermothertrans[i] = new TGeoTranslation(0.,
1285 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1286 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1287 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1288 * fgkCarbonFiberJunctionWidth,0.);
1289 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1290 *localladdermotherrot);
1291 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1292 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
1294 /////////////////////////////////////////////////////////////
1295 // Ladder Cables Matrices
1296 /////////////////////////////////////////////////////////////
1297 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
1298 + fgkSSDFlexHeight[1];
1299 Double_t ssdladdercabletransx[3];
1300 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1301 * SinD(2.*fgkSSDFlexAngle)
1302 * CosD(2.*fgkSSDFlexAngle);
1303 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1304 - ssdladdercabletransx[0]
1305 / SinD(2.*fgkSSDFlexAngle))
1306 * CosD(fgkSSDFlexAngle);
1307 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1308 * TMath::DegToRad()*ssdflexradiusmax
1309 - fgkSSDFlexLength[2]-TMath::Pi()
1310 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1311 - fgkSSDLadderCableWidth)
1312 * CosD(2.*fgkSSDFlexAngle);
1313 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
1314 * TanD(2.*fgkSSDFlexAngle),
1315 ssdladdercabletransx[1]
1316 * TanD(fgkSSDFlexAngle),
1317 ssdladdercabletransx[2]
1318 * TanD(2.*fgkSSDFlexAngle)};
1319 TGeoRotation* localladdercablerot[3];
1320 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1321 localladdercablerot[0]->SetAngles(90.,0.,0.);
1322 localladdercablerot[1]->SetAngles(90.,60.,-90.);
1323 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1324 * (*localladdercablerot[0]));
1325 //TGeoRotation* localladdercablerot = new TGeoRotation();
1326 //localladdercablerot->SetAngles(90.,0.,0.);
1327 ////////////////////////////////////////////
1328 // LocalLadderCableCombiTransMatrix
1329 ////////////////////////////////////////////
1330 const Int_t klocalladdersidecablesnumber = 2;
1331 const Int_t klocalladdercombitransnumber = 5;
1332 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1333 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1334 localladdercablecombitransmatrix[i] =
1335 new TGeoCombiTrans*[klocalladdercombitransnumber];
1336 ///////////////////////////////////////////
1337 // Left Side Ladder Cables Transformations
1338 ///////////////////////////////////////////
1339 localladdercablecombitransmatrix[0][0] =
1340 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1342 localladdercablecombitransmatrix[0][1] =
1343 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1344 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1345 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1346 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1347 - 0.5*(fgkCarbonFiberLowerSupportWidth
1348 + fgkSSDSensorCenterSupportLength
1349 - fgkSSDSensorCenterSupportThickness[0]),
1350 - (fgkSSDModuleCoolingBlockToSensor
1351 + 0.5*fgkCoolingTubeSupportHeight
1352 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1353 - fgkSSDChipHeight),NULL);
1354 localladdercablecombitransmatrix[0][2] =
1355 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1356 fgkSSDModuleStiffenerPosition[1],0.,0);
1357 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1358 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1359 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1360 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1361 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1362 new TGeoRotation("",180.,0.,0.));
1363 localladdercablecombitransmatrix[0][4] =
1364 new TGeoCombiTrans(-ssdladdercabletransx[0]
1365 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
1366 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1368 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1369 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
1370 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1371 + ssdladdercabletransz[2],localladdercablerot[2]);
1372 ///////////////////////////////////////////
1373 // Rigth Side Ladder Cables Transformations
1374 ///////////////////////////////////////////
1375 TGeoCombiTrans* localladdercablessdmodulematrix =
1376 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1377 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1378 fgkSSDStiffenerWidth,
1379 - 0.5*fgkSSDFlexHeight[0],NULL);
1380 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1381 localladdercablecombitransmatrix[1][i] =
1382 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1383 new TGeoCombiTrans(*localladdercablessdmodulematrix));
1384 ///////////////////////////////////////////
1385 // Setting LadderCableHMatrix
1386 ///////////////////////////////////////////
1387 Int_t beamaxistrans[2][3];
1388 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1389 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1390 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1391 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1392 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1393 beamaxistrans[1][2] = beamaxistrans[1][0];
1394 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1395 TGeoRotation* laddercablerot = new TGeoRotation();
1396 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1397 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1398 Double_t* laddercabletransvector;
1399 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1400 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1401 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1403 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1404 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1405 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1406 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1407 localladdercablehmatrix[i][j]->MultiplyLeft(
1408 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1410 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1411 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1412 laddercabletrans->SetTranslation(laddercabletransvector[0],
1413 laddercabletransvector[1]
1414 + (j==0 ? beamaxistrans[i][0] : 0.)
1415 * fgkCarbonFiberJunctionWidth,
1416 laddercabletransvector[2]);
1417 laddercablecombitrans->SetRotation(*laddercablerot);
1418 laddercablecombitrans->SetTranslation(*laddercabletrans);
1419 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1421 fladdercablematrix[i][2] =
1422 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1423 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1424 fladdercablematrix[i][3] =
1425 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1426 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1428 for(Int_t i=0; i<fgkladdercablesnumber; i++)
1429 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1430 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1432 ///////////////////////////////////////////
1433 // Setting Ladder HMatrix
1434 ///////////////////////////////////////////
1435 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1436 fgkSSDLay6SensorsNumber};
1437 for(Int_t i=0; i<fgkladdernumber; i++){
1438 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1439 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1440 fladdermatrix[i][j] = new TGeoHMatrix();
1441 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1442 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1443 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1446 ///////////////////////////////////////////
1447 // Setting SSD Sensor Matrix
1448 ///////////////////////////////////////////
1449 TGeoCombiTrans* localssdsensorcombitrans[2];
1450 TGeoRotation* localssdsensorrot = new TGeoRotation();
1451 localssdsensorrot->SetAngles(0.,90.,0.);
1452 TGeoTranslation* localssdsensortrans[2];
1453 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1454 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1455 fgkCarbonFiberJunctionWidth
1456 - fgkCarbonFiberLowerSupportWidth
1457 - fgkLowerSupportToSensorZ,
1458 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1459 - fgkSSDModuleCoolingBlockToSensor
1460 + (fgkSSDSensorSideSupportHeight[1]
1461 - fgkSSDSensorSideSupportHeight[0]));
1462 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1463 fgkCarbonFiberJunctionWidth
1464 - fgkCarbonFiberLowerSupportWidth
1465 - fgkLowerSupportToSensorZ,
1466 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1467 -fgkSSDModuleCoolingBlockToSensor);
1469 for(Int_t i=0; i<2; i++)
1470 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1471 *localssdsensorrot);
1472 for(Int_t i=0; i<fgkladdernumber; i++){
1473 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1474 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1476 case 0: //Ladder of Layer5
1477 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1478 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1479 *localssdsensorcombitrans[1])));
1481 case 1: //Ladder of Layer6
1482 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1483 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1484 *localssdsensorcombitrans[0])));
1489 //////////////////////////
1490 // Setting SSD End Ladder
1491 //////////////////////////
1492 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1493 for(Int_t i=0; i<2; i++){
1494 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1495 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1496 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1497 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1498 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1499 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1500 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1501 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1503 /////////////////////////////////////////////////////
1504 // Setting the CombiTransformation to pass ITS center
1505 /////////////////////////////////////////////////////
1506 Double_t itscentertransz[fgklayernumber];
1507 itscentertransz[0] = fgkSSDLay5LadderLength
1508 - fgkLay5CenterITSPosition;
1509 itscentertransz[1] = fgkSSDLay6LadderLength
1510 - fgkLay6CenterITSPosition;
1511 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1512 + 0.5*fgkCoolingTubeSupportHeight;
1513 TGeoRotation* itscenterrot[3];
1514 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1515 itscenterrot[0]->SetAngles(90.,180.,-90.);
1516 itscenterrot[1]->SetAngles(0.,90.,0.);
1517 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1518 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1519 for(Int_t i=0; i<fgklayernumber; i++)
1520 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1522 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1523 - itscentertransz[i],itscenterrot[2]);
1524 TGeoRotation** locallayerrot[fgklayernumber];
1525 TGeoTranslation** locallayertrans[fgklayernumber];
1526 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1527 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1528 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1529 - fgkLay5CenterITSPosition);
1530 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1531 - fgkLay6CenterITSPosition);
1532 const Int_t kssdlayladdernumber[fgklayernumber] =
1533 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1534 for(Int_t i=0; i<fgklayernumber; i++){
1535 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1536 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1537 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1538 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1540 Double_t layerladderangleposition[fgklayernumber] =
1541 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1542 Double_t layerradius = 0.;
1543 for(Int_t i=0; i<fgklayernumber; i++){
1544 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1546 case 0: //Ladder of Layer5
1547 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1549 case 1: //Ladder of Layer6
1550 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1553 locallayerrot[i][j] = new TGeoRotation();
1554 locallayertrans[i][j] = new TGeoTranslation();
1555 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1556 locallayertrans[i][j]->SetTranslation(layerradius
1557 * CosD(90.0+j*layerladderangleposition[i]),
1559 * SinD(90.0+j*layerladderangleposition[i]),0.);
1560 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1561 *locallayerrot[i][j]);
1562 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1563 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1564 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1567 /////////////////////////////////////////////////////////////
1568 // Deallocating memory
1569 /////////////////////////////////////////////////////////////
1570 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1571 delete carbonfiberot[i];
1572 delete localcarbonfibersupportmatrix[i];
1574 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1575 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1576 delete localcarbonfiberjunctionmatrix[i][j];
1577 delete localcarbonfiberjunctionrot[i][j];
1578 delete localcarbonfiberjunctiontrans[i][j];
1580 delete [] localcarbonfiberjunctionmatrix[i];
1581 delete [] localcarbonfiberjunctionrot[i];
1582 delete [] localcarbonfiberjunctiontrans[i];
1584 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1585 delete localcarbonfiberlowersupportrans[i];
1586 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1587 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1588 delete localssdsensorsupportmatrix[i][j];
1589 delete localssdsensorsupportrot[i][j];
1590 delete localssdsensorsupportrans[i][j];
1592 delete [] localssdsensorsupportmatrix[i];
1593 delete [] localssdsensorsupportrot[i];
1594 delete [] localssdsensorsupportrans[i];
1596 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1597 delete localcoolingtubesupportmatrix[i];
1598 delete localcoolingtubesupportrot[i];
1599 delete localcoolingtubesupportrans[i];
1601 for(Int_t j=0; j<2; j++){
1602 delete localcoolingtubevect[j];
1603 delete localcoolingtubetrans[j];
1605 delete endladdermountingblockrot;
1606 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1607 for(Int_t i=0; i<fgkflexnumber; i++){
1608 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1609 delete localflexmatrix[i][j];
1610 delete [] localflexmatrix[i];
1612 delete localendlladdercoolingtuberot;
1613 for(Int_t i=0; i<2; i++){
1614 for(Int_t j=0; j<2; j++)
1615 delete localendlladdercoolingtubetrans[i][j];
1616 delete [] localendlladdercoolingtubetrans[i];
1619 delete localflexrot;
1620 delete localendflexrot;
1621 delete localendflexmatrix;
1622 for(Int_t i=0; i<fgkladdernumber; i++){
1623 delete localladdermothertrans[i];
1624 delete localladdermothercombitrans[i];
1626 delete localladdermotherrot;
1627 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1628 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1629 delete localendladdercarbonfiberjunctionmatrix[i][j];
1630 delete localendladdercarbonfiberjunctionrot[i][j];
1631 delete localendladdercarbonfiberjunctiontrans[i][j];
1633 delete [] localendladdercarbonfiberjunctionmatrix[i];
1634 delete [] localendladdercarbonfiberjunctionrot[i];
1635 delete [] localendladdercarbonfiberjunctiontrans[i];
1636 delete localendladdercarbonfiberjunctionglobalrot[i];
1637 delete localendladdercarbonfiberjunctionglobaltrans[i];
1638 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1640 for(Int_t i=0; i<2; i++){
1641 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1642 delete [] localendladdercooltubetrans[i];
1644 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1645 delete localendladdercarbonfibertrans[i];
1646 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1647 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1648 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1649 delete localladdercablecombitransmatrix[i][j];
1650 delete []localladdercablecombitransmatrix[i];
1652 delete localendladdercliprot;
1653 delete localendladdercliptrans;
1654 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1655 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1656 delete localladdercablehmatrix[i][j];
1657 delete []localladdercablehmatrix[i];
1659 delete laddercablerot;
1660 delete laddercabletrans;
1661 delete laddercablecombitrans;
1662 delete localladdercablessdmodulematrix;
1663 delete localssdsensorrot;
1664 for(Int_t i=0; i<2; i++){
1665 delete localssdsensortrans[i];
1666 delete localssdsensorcombitrans[i];
1668 for(Int_t i=0; i<fgklayernumber; i++){
1669 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1670 delete locallayerrot[i][j];
1671 delete locallayertrans[i][j];
1672 delete locallayercombitrans[i][j];
1674 delete [] locallayerrot[i];
1675 delete [] locallayertrans[i];
1676 delete [] locallayercombitrans[i];
1677 delete localbeamaxistrans[i];
1679 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1680 for(Int_t i=0; i<fgkladdernumber; i++){
1681 for(Int_t j=0; j<fgkladdernumber; j++)
1682 delete ladderglobalmatrix[i][j];
1683 delete [] ladderglobalmatrix[i];
1685 /////////////////////////////////////////////////////////////
1686 fTransformationMatrices = kTRUE;
1688 ///////////////////////////////////////////////////////////////////////////////
1689 void AliITSv11GeometrySSD::CreateBasicObjects(){
1690 /////////////////////////////////////////////////////////////
1691 // Method generating the Objects of SSD Geometry
1692 /////////////////////////////////////////////////////////////
1694 ///////////////////////////////////
1696 /////////////////////////////////////////////////////////////
1697 // Carbon Fiber Support
1698 /////////////////////////////////////////////////////////////
1699 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1700 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1701 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
1702 /////////////////////////////////////////////////////////////
1703 // Carbon Fiber Junction
1704 /////////////////////////////////////////////////////////////
1705 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
1706 /////////////////////////////////////////////////////////////
1707 // Carbon Fiber Lower Support
1708 /////////////////////////////////////////////////////////////
1709 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1710 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1711 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1712 /////////////////////////////
1713 // SSD Sensor Support
1714 /////////////////////////////
1715 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1716 new TGeoVolume*[fgkssdsensorsupportnumber];
1717 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
1718 fgkSSDSensorSideSupportThickness[1]};
1719 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1720 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1721 fgkSSDSensorSideSupportHeight[i],
1722 fgkSSDSensorSideSupportWidth,
1723 sidesupporthickness);
1724 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1725 fgkSSDSensorCenterSupportHeight[i],
1726 fgkSSDSensorCenterSupportWidth,
1727 sidesupporthickness);
1729 /////////////////////////////////////////////////////////////
1730 // SSD Cooling Tube Support
1731 /////////////////////////////////////////////////////////////
1732 Int_t edgesnumber = 3;
1733 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1734 /////////////////////////////////////////////////////////////
1736 /////////////////////////////////////////////////////////////
1737 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1738 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1739 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1740 /////////////////////////////////////////////////////////////
1741 // SSD Cooling Block System
1742 /////////////////////////////////////////////////////////////
1743 fssdcoolingblocksystem = GetCoolingBlockSystem();
1744 /////////////////////////////////////////////////////////////
1746 /////////////////////////////////////////////////////////////
1747 CreateCoolingTubes();
1748 /////////////////////////////////////////////////////////////
1750 /////////////////////////////////////////////////////////////
1751 fssdstiffenerflex = GetSSDStiffenerFlex();
1752 fssdendflex = GetSSDEndFlex();
1753 ///////////////////////////////////
1754 // End Ladder Carbon Fiber Junction
1755 ///////////////////////////////////
1756 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1757 fendladdercarbonfiberjunction[i] =
1758 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1759 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1760 fendladdercarbonfiberjunction[i][0] =
1761 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
1762 fendladdercarbonfiberjunction[i][1] =
1763 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
1765 ///////////////////////////////////
1766 // End Ladder Mounting Block
1767 ///////////////////////////////////
1768 fendladdermountingblock = GetSSDMountingBlock();
1769 ///////////////////////////////////
1770 // End Ladder Mounting Block
1771 ///////////////////////////////////
1772 fendladdermountingblockclip = GetMountingBlockClip();
1773 ///////////////////////////////////
1775 ///////////////////////////////////
1776 TList* laddersupportlist = GetMountingBlockSupport(20);
1777 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1778 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1779 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1780 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
1781 /////////////////////////////////////////////////////////////
1782 // Deallocating memory
1783 /////////////////////////////////////////////////////////////
1784 delete carbonfibersupportlist;
1785 delete carbonfiberlowersupportlist;
1786 delete ssdhybridcomponentslist;
1787 delete laddersupportlist;
1788 /////////////////////////////////////////////////////////////
1789 fBasicObjects = kTRUE;
1791 /////////////////////////////////////////////////////////////////////////////////
1792 void AliITSv11GeometrySSD::SetSSDSensor(){
1793 ////////////////////////////////////////////////////////////////
1794 // Method generating SSD Sensors: it sets the private variables
1795 // fSSDSensor5, fSSDSensor6
1796 ////////////////////////////////////////////////////////////////
1797 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1798 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1799 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
1800 0.5*ssdsensitivewidth,
1801 0.5*fgkSSDSensorHeight,
1802 0.5*ssdsensitivelength);
1803 TGeoVolume* ssdsensorsensitiveLay5 =
1804 new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
1805 TGeoVolume* ssdsensorsensitiveLay6 =
1806 new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
1807 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1808 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
1809 TGeoBBox* ssdsensorinsensitiveshape[2];
1810 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
1811 0.5*fgkSSDSensorInsensitiveWidth,
1812 0.5*fgkSSDSensorHeight,
1813 0.5*fgkSSDSensorLength);
1814 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
1815 0.5*ssdsensitivewidth,
1816 0.5*fgkSSDSensorHeight,
1817 0.5*fgkSSDSensorInsensitiveWidth);
1818 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
1819 "SSDSensorInsensitive2"};
1820 TGeoVolume* ssdsensorinsensitive[2];
1821 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1822 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1824 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
1826 /////////////////////////////////////////////////////////////
1827 // Virtual Volume containing SSD Sensor
1828 /////////////////////////////////////////////////////////////
1829 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1830 0.5*fgkSSDSensorWidth,
1831 0.5*fgkSSDSensorHeight,
1832 0.5*fgkSSDSensorLength);
1833 fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
1835 fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
1837 /////////////////////////////////////////////////////////////
1838 for(Int_t i=0; i<4; i++){
1839 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1840 ssdsensorinsensitive[1],i<2?1:2,
1841 new TGeoTranslation(
1842 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1843 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1844 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1845 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1846 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1847 ssdsensorinsensitive[1],i<2?1:2,
1848 new TGeoTranslation(
1849 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1850 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1851 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1852 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1854 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1855 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
1857 ///////////////////////////////////////////////////////////////////////////////
1858 TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1859 /////////////////////////////////////////////////////////////
1860 // Method generating the Carbon Fiber Support
1861 /////////////////////////////////////////////////////////////
1862 const Int_t kvertexnumber = 4;
1863 const Int_t kshapesnumber = 2;
1864 TVector3** vertexposition[kshapesnumber];
1865 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1866 Double_t carbonfibersupportxaxisEdgeproj =
1867 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1868 * TMath::DegToRad());
1869 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1870 / fgkCarbonFiberSupportXAxisLength);
1871 /////////////////////
1872 //Vertex Positioning
1873 ////////////////////
1874 vertexposition[0][0] = new TVector3();
1875 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1876 fgkCarbonFiberSupportYAxisLength);
1877 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1878 carbonfibersupportxaxisEdgeproj
1879 * TMath::Tan(theta));
1880 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1881 - carbonfibersupportxaxisEdgeproj,
1882 fgkCarbonFiberSupportYAxisLength
1883 - vertexposition[0][2]->Y());
1884 ////////////////////////////////////////////////////
1885 //Setting the parameters for Isometry Transformation
1886 ////////////////////////////////////////////////////
1887 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1888 + fgkCarbonFiberSupportTopEdgeDist[0]
1889 + fgkCarbonFiberSupportWidth);
1890 Double_t* param = new Double_t[4];
1891 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1892 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1893 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1894 (GetReflection(vertexposition[0][j],param))->Y());
1895 const char* carbonfibersupportshapename[kshapesnumber] =
1896 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1897 const char* carbonfibersupportname[kshapesnumber] =
1898 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1899 TGeoArb8* carbonfibersupportshape[kshapesnumber];
1900 TGeoVolume* carbonfibersupport[kshapesnumber];
1901 TList* carbonfibersupportlist = new TList();
1902 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1903 Double_t carbonfibersupportheight =
1904 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1905 *TMath::DegToRad());
1906 for(Int_t i = 0; i< kshapesnumber; i++){
1907 carbonfibersupportshape[i] =
1908 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1909 carbonfibersupportshapename[i],i==0 ? 1: -1);
1910 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1911 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1912 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1913 carbonfibersupportlist->Add(carbonfibersupport[i]);
1915 /////////////////////////////////////////////////////////////
1916 // Deallocating memory
1917 /////////////////////////////////////////////////////////////
1918 for(Int_t i=0; i< kshapesnumber; i++){
1919 for(Int_t j=0; j< kvertexnumber; j++)
1920 delete vertexposition[i][j];
1921 delete [] vertexposition[i];
1924 /////////////////////////////////////////////////////////////
1925 return carbonfibersupportlist;
1927 /////////////////////////////////////////////////////////////////////////////////
1928 TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
1929 /////////////////////////////////////////////////////////////
1930 // Method generating SSD Carbon Fiber Junction
1931 /////////////////////////////////////////////////////////////
1932 const Int_t kvertexnumber = 6;
1933 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
1934 Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1935 * TMath::DegToRad()),-1.,0.,0.};
1936 TVector3* vertex[kvertexnumber];
1937 vertex[0] = new TVector3();
1938 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
1939 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1940 * TMath::DegToRad()),
1941 fgkCarbonFiberJunctionEdge[0]
1942 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
1943 * TMath::DegToRad()));
1944 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
1945 fgkCarbonFiberJunctionEdge[1]);
1946 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
1947 vertex[1] = GetReflection(vertex[5],reflectionparam);
1948 vertex[2] = GetReflection(vertex[4],reflectionparam);
1949 Double_t xvertexpoints[6], yvertexpoints[6];
1950 for(Int_t i=0; i<kvertexnumber; i++)
1951 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
1952 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
1953 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
1954 carbonfiberjunctionshape->DefineSection(1,0.5*width);
1955 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
1956 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
1957 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
1958 /////////////////////////////////////////////////////////////
1959 // Deallocating memory
1960 /////////////////////////////////////////////////////////////
1961 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
1962 /////////////////////////////////////////////////////////////
1963 return carbonfiberjunction;
1965 ////////////////////////////////////////////////////////////////////////////////
1966 TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
1967 /////////////////////////////////////////////////////////////
1968 // Method generating the Carbon Fiber Lower Support
1969 /////////////////////////////////////////////////////////////
1970 const Int_t kvertexnumber = 4;
1971 const Int_t kshapesnumber = 2;
1972 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
1973 fgkCarbonFiberLowerSupportWidth};
1974 TVector3** vertexposition[kshapesnumber];
1975 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
1976 new TVector3*[kvertexnumber];
1977 //First Shape Vertex Positioning
1978 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
1979 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
1980 - fgkCarbonFiberLowerSupportLowerLenght);
1981 vertexposition[0][2] = new TVector3();
1982 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
1983 //Second Shape Vertex Positioning
1984 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
1985 - fgkCarbonFiberLowerSupportVolumePosition[0])
1986 / fgkCarbonFiberTriangleLength);
1987 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
1988 vertexposition[0][0]->X()*TMath::Tan(theta)
1989 + fgkCarbonFiberLowerSupportVolumePosition[0]);
1990 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
1991 vertexposition[0][1]->X()*TMath::Tan(theta)
1992 + fgkCarbonFiberLowerSupportVolumePosition[0]);
1993 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
1994 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
1995 fgkCarbonFiberLowerSupportVolumePosition[1]);
1996 const char* carbonfiberlowersupportshapename[kshapesnumber] =
1997 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
1998 const char* carbonfiberlowersupportname[kshapesnumber] =
1999 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2000 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2001 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2002 TList* carbonfiberlowersupportlist = new TList();
2003 for(Int_t i = 0; i< kshapesnumber; i++){
2004 carbonfiberlowersupportshape[i] =
2005 GetArbShape(vertexposition[i],width,
2006 fgkCarbonFiberLowerSupportHeight,
2007 carbonfiberlowersupportshapename[i]);
2008 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2009 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2010 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2011 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2013 /////////////////////////////////////////////////////////////
2014 // Deallocating memory
2015 /////////////////////////////////////////////////////////////
2016 for(Int_t i=0; i< kshapesnumber; i++){
2017 for(Int_t j=0; j< kvertexnumber; j++)
2018 delete vertexposition[i][j];
2019 delete [] vertexposition[i];
2021 /////////////////////////////////////////////////////////////
2022 return carbonfiberlowersupportlist;
2024 ///////////////////////////////////////////////////////////////////////////////
2025 TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2026 Double_t width, Double_t* thickness)const{
2027 /////////////////////////////////////////////////////////////
2028 // Method generating the Sensor Support
2029 /////////////////////////////////////////////////////////////
2030 const Int_t kvertexnumber = 6;
2031 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2032 TVector3* vertexposition[kvertexnumber];
2033 vertexposition[0] = new TVector3();
2034 vertexposition[1] = new TVector3(0.0,length);
2035 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2036 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2037 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2038 vertexposition[5] = new TVector3(vertexposition[4]->X());
2039 Double_t xvertexpoints[6], yvertexpoints[6];
2040 for(Int_t i=0; i<kvertexnumber; i++)
2041 xvertexpoints[i] = vertexposition[i]->X(),
2042 yvertexpoints[i] = vertexposition[i]->Y();
2043 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2044 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2045 ssdsensorsupportshape->DefineSection(1,0.5*width);
2046 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2047 ssdsensorsupportshape,fSSDSensorSupportMedium);
2048 /////////////////////////////////////////////////////////////
2049 // Deallocating memory
2050 /////////////////////////////////////////////////////////////
2051 for (Int_t i=0; i<kvertexnumber; i++)
2052 delete vertexposition[i];
2053 /////////////////////////////////////////////////////////////
2054 return ssdsensorsupport;
2056 ////////////////////////////////////////////////////////////////////////////////
2057 TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2058 /////////////////////////////////////////////////////////////
2059 // Method generating the Cooling Tube Support
2060 /////////////////////////////////////////////////////////////
2061 if(nedges%2!=0) nedges--;
2062 const Int_t kvertexnumber = nedges+5;
2063 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2064 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2065 Double_t angle = 90.+phi;
2066 Double_t psi = 90.-phi;
2067 ///////////////////////////////////////
2068 // Vertex Positioning for TGeoXTru
2069 ///////////////////////////////////////
2070 TVector3** vertexposition = new TVector3*[kvertexnumber];
2072 Double_t Router = fgkCoolingTubeSupportRmin/CosD(phi/nedges); // Recalc inner radius so that tube fits inside
2073 vertexposition[0] = new TVector3(Router*CosD(angle),
2074 Router*SinD(angle));
2075 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2076 fgkCoolingTubeSupportRmax*SinD(angle));
2077 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2078 fgkCoolingTubeSupportRmax);
2079 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2080 fgkCoolingTubeSupportRmax);
2081 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2082 vertexposition[1]->Y());
2084 for(Int_t i=0; i<nedges; i++)
2085 vertexposition[i+5] =
2086 new TVector3(Router*CosD(psi+i*(2.*phi/nedges)),
2087 Router*SinD(psi+i*(2.*phi/nedges)));
2088 ///////////////////////////////////////////////////////////////////////
2089 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2090 ///////////////////////////////////////////////////////////////////////
2091 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2092 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2093 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2094 for(Int_t i=0; i<kvertexnumber; i++){
2095 xvertexpoints[i] = vertexposition[i]->X();
2096 yvertexpoints[i] = vertexposition[i]->Y();
2098 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2100 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2101 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2102 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2103 coolingtubesupportarcshape,
2104 fSSDTubeHolderMedium);
2105 coolingtubesupportarc->SetLineColor(fColorG10);
2106 //////////////////////////////////////////////////////////////////////////
2107 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2108 //////////////////////////////////////////////////////////////////////////
2109 TGeoTubeSeg* coolingtubesupportsegshape =
2110 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2111 fgkCoolingTubeSupportRmax,
2112 0.5*fgkCoolingTubeSupportWidth,
2114 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2115 coolingtubesupportsegshape,
2116 fSSDTubeHolderMedium);
2117 coolingtubesupportseg->SetLineColor(fColorG10);
2118 //////////////////////////////////////////////////////////////////////////
2119 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2120 //////////////////////////////////////////////////////////////////////////
2121 Double_t* boxorigin = new Double_t[3];
2122 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2123 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2124 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2125 0.5*fgkCoolingTubeSupportHeight,
2126 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2127 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2128 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2129 coolingtubesupportbox->SetLineColor(fColorG10);
2130 //////////////////////////////////////////////////////////////////////////
2131 // Cooling Tube for Cooling Tube Support
2132 //////////////////////////////////////////////////////////////////////////
2133 TGeoXtru* coolingtubearcshape[2];
2134 coolingtubearcshape[0] = new TGeoXtru(2);
2135 Double_t* xvert = new Double_t[nedges+2];
2136 Double_t* yvert = new Double_t[nedges+2];
2137 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2138 ////////////////////////////////////////
2139 // Positioning the vertices for TGeoXTru
2140 ////////////////////////////////////////
2141 xvert[0] = 0., yvert[0] = 0.;
2142 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2143 for(Int_t i=0; i< nedges; i++)
2144 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2145 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2146 ////////////////////////////////////////
2147 // Defining TGeoXTru PolyGone
2148 ////////////////////////////////////////
2149 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2150 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2151 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2152 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2153 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2154 TGeoVolume* coolingtubearc[2];
2155 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2156 coolingtubearcshape[0],fSSDCoolingTubeWater);
2157 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2158 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2159 coolingtubearc[0]->SetLineColor(fColorWater);
2160 coolingtubearc[1]->SetLineColor(fColorPhynox);
2161 ////////////////////////////////////////////
2162 // Defining TGeoTubeSeg Part of Cooling Tube
2163 ////////////////////////////////////////////
2164 TGeoTubeSeg* coolingtubesegshape[2];
2165 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2166 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2167 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2168 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2169 TGeoVolume* coolingtubeseg[2];
2170 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2171 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2172 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2173 coolingtubesegshape[1],fSSDCoolingTubeWater);
2174 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2175 coolingtubeseg[1]->SetLineColor(fColorWater);
2176 /////////////////////////////////////////////////////////////
2177 // Virtual Volume containing Cooling Tube Support
2178 /////////////////////////////////////////////////////////////
2179 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2180 const Int_t kvirtualvertexnumber = 8;
2181 TVector3* virtualvertex[kvirtualvertexnumber];
2182 ////////////////////////////////////////
2183 // Positioning the vertices for TGeoXTru
2184 ////////////////////////////////////////
2185 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2186 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2187 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2188 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2189 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2190 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2191 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2192 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2193 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2194 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2195 xmothervertex[i] = virtualvertex[i]->X(),
2196 ymothervertex[i] = virtualvertex[i]->Y();
2197 ////////////////////////////////////////
2198 // Defining TGeoXTru PolyGone
2199 ////////////////////////////////////////
2200 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2202 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2203 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2204 /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2205 virtualCoolingTubeSupportShape,fSSDAir); */
2206 TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
2208 ////////////////////////////////////////
2209 // Positioning Volumes in Virtual Volume
2210 ////////////////////////////////////////
2211 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2212 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2213 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2214 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2215 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2216 //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2217 //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2218 //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2219 //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2220 /////////////////////////////////////////////////////////////
2221 // Deallocating memory
2222 /////////////////////////////////////////////////////////////
2223 delete [] vertexposition;
2224 delete [] xvertexpoints;
2225 delete [] yvertexpoints;
2228 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2229 delete virtualvertex[i];
2230 /////////////////////////////////////////////////////////////
2231 return virtualcoolingtubesupport;
2233 /////////////////////////////////////////////////////////////////////////////////
2234 TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2235 /////////////////////////////////////////////////////////////
2236 // Method generating List containing SSD Hybrid Components
2237 /////////////////////////////////////////////////////////////
2238 TList* ssdhybridlist = new TList();
2239 const Int_t kssdstiffenernumber = 2;
2240 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2241 - 2.*fgkSSDModuleStiffenerPosition[1]
2242 - fgkSSDStiffenerWidth;
2243 Double_t ssdchipcablesradius[kssdstiffenernumber];
2244 for(Int_t i=0; i<kssdstiffenernumber; i++)
2245 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2246 - fgkSSDChipCablesHeight[0]
2247 - fgkSSDChipCablesHeight[1]);
2248 /////////////////////////////////////////////////////////////
2249 // Mother Volumes Containers
2250 /////////////////////////////////////////////////////////////
2251 const Int_t kmothernumber = 2;
2252 const Int_t kmothervertexnumber = 8;
2253 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2254 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2256 TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
2257 TGeoVolume* ssdhybridmother[kmothernumber][2];
2259 TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
2260 TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
2261 TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
2263 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2264 for(Int_t i=0; i<kmothernumber; i++){
2265 xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
2266 ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
2267 xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
2268 ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2269 -fgkSSDChipCablesHeight[i+2];
2271 xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
2272 ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
2273 xmothervertex[i][3] = xmothervertex[i][2];
2274 ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1];
2276 xmothervertex[i][4] = xmothervertex[i][2]-0.4;
2277 ymothervertex[i][4] = ymothervertex[i][3];
2278 xmothervertex[i][5] = xmothervertex[i][4];
2279 ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i];
2281 xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
2282 ymothervertex[i][6] = ymothervertex[i][5];
2284 xmothervertex[i][7] = xmothervertex[i][6];
2285 ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
2286 TGeoXtru *shape = new TGeoXtru(2);
2287 shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
2288 shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
2289 shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
2290 ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
2291 ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
2292 ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
2294 /////////////////////////////////////////////////////////////
2296 /////////////////////////////////////////////////////////////
2297 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2298 0.5*fgkSSDStiffenerLength,
2299 0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
2300 0.5*fgkSSDStiffenerHeight);
2301 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2302 fSSDStiffenerMedium);
2303 ssdstiffener->SetLineColor(fColorStiffener);
2305 ////////////////////////////
2306 // Capacitor 0603-2200 nF
2307 ///////////////////////////
2308 const Int_t knapacitor0603number = 5;
2309 TGeoBBox* capacitor0603mothershape = new TGeoBBox("Capacitor0603MotherShape",
2310 0.5*fgkSSDCapacitor0603Length + fgkSSDCapacitor0603CapLength,
2311 0.5*fgkSSDCapacitor0603Width,
2312 0.5*fgkSSDCapacitor0603Height);
2313 TGeoVolume* capacitor0603mother = new TGeoVolume("Capacitor0603Mother",capacitor0603mothershape,
2316 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
2317 0.5*fgkSSDCapacitor0603Length,
2318 0.5*fgkSSDCapacitor0603Width,
2319 0.5*fgkSSDCapacitor0603Height);
2320 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
2321 fSSDStiffener0603CapacitorMedium);
2322 capacitor0603->SetLineColor(fColorAl);
2323 TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.);
2324 capacitor0603mother->AddNode(capacitor0603,1,cap0603trans);
2326 TGeoBBox* capacitor0603capshape = new TGeoBBox("Capacitor0603CapShape",
2327 0.5*fgkSSDCapacitor0603CapLength,
2328 0.5*fgkSSDCapacitor0603Width,
2329 0.5*fgkSSDCapacitor0603Height);
2330 TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape,
2331 fSSDStiffenerCapacitorCapMedium);
2332 capacitor0603cap->SetLineColor(fColorNiSn);
2333 TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.);
2334 capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1);
2335 TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.);
2336 capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2);
2339 TGeoVolume* ssdchip = GetSSDChip();
2341 const Int_t knedges = 5;
2342 TGeoVolume *ssdchipcables[2];
2344 for(Int_t i=0; i<kmothernumber; i++){
2345 for(Int_t j=0; j<kssdstiffenernumber; j++){
2346 ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
2347 for(Int_t k=1; k<knapacitor0603number+1; k++){
2348 ssdhybridmother[i][j]->AddNode(capacitor0603mother,k,
2349 new TGeoCombiTrans("",
2350 -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
2351 -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
2352 (k-3.)/6*fgkSSDStiffenerLength,
2353 hybridmotherrotInv));
2357 GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
2358 for(Int_t k=0; k<fgkSSDChipNumber; k++){
2359 TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
2360 - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
2361 - fgkSSDChipCablesHeight[i+2],
2362 (k+0.5-fgkSSDChipNumber/2)*
2363 (fgkSSDChipLength + fgkSSDChipSeparationLength));
2364 TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
2365 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
2366 (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
2367 hybridmotherrotInv);
2368 for(Int_t j=0; j<kssdstiffenernumber; j++){
2369 ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
2370 ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
2373 // Final placement by assembly
2374 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
2375 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
2376 ssdhybridlist->Add(ssdhybridassembly[i]);
2378 /////////////////////////////////////////////////////////////
2379 // Mother Volume Containing Capacitor Part
2380 /////////////////////////////////////////////////////////////
2381 const Int_t kcapacitormothernumber = 8;
2382 Double_t xcapacitorvertex[kcapacitormothernumber];
2383 Double_t ycapacitorvertex[kcapacitormothernumber];
2384 ///////////////////////
2385 // Setting the vertices
2386 ///////////////////////
2387 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2388 xcapacitorvertex[1] = xcapacitorvertex[0];
2389 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2390 xcapacitorvertex[3] = xcapacitorvertex[2];
2391 xcapacitorvertex[4] = xcapacitorvertex[0];
2392 xcapacitorvertex[5] = xcapacitorvertex[0];
2393 xcapacitorvertex[6] = -xcapacitorvertex[0];
2394 xcapacitorvertex[7] = xcapacitorvertex[6];
2395 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2396 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2397 ycapacitorvertex[2] = ycapacitorvertex[1];
2398 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2399 ycapacitorvertex[4] = ycapacitorvertex[3];
2400 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2401 ycapacitorvertex[6] = ycapacitorvertex[5];
2402 ycapacitorvertex[7] = ycapacitorvertex[0];
2403 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2404 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2406 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2407 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2408 // TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2410 TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
2411 ////////////////////////////
2413 ///////////////////////////
2414 const Int_t kssdconnectorlayernumber = 3;
2415 TGeoBBox* ssdconnectorshape[kssdconnectorlayernumber];
2416 Double_t ssdConnectorThickness[kssdconnectorlayernumber]={fgkSSDConnectorAlHeight,fgkSSDConnectorNiHeight,fgkSSDConnectorSnHeight};
2418 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2419 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2420 + fgkSSDConnectorAlHeight};
2422 Double_t ssdconnectororigin[3] = {0,0,0.5*fgkSSDStiffenerHeight};
2423 const char* ssdconnectorname[kssdconnectorlayernumber] = {"SSDConnectorAl","SSDConnectorNi","SSDConnectorSn"};
2424 TGeoMedium *ssdConnectorMedium[kssdconnectorlayernumber]={fSSDAlTraceFlexMedium,fSSDStiffenerConnectorMedium,fSSDSn};
2425 TGeoVolume* ssdconnector[kssdconnectorlayernumber];
2426 for(Int_t i=0; i<kssdconnectorlayernumber; i++){
2427 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
2428 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2429 0.5*fgkSSDConnectorWidth,
2430 0.5*ssdConnectorThickness[i],
2431 ssdconnectororigin);
2432 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
2433 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2434 ssdConnectorMedium[i]);
2435 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorNiSn);
2437 const Int_t kssdconnectornumber = 4;
2438 TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
2439 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2440 + fgkSSDConnectorPosition[0]
2441 - fgkSSDConnectorSeparation
2442 - 1.5*fgkSSDConnectorLength,
2443 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2444 - fgkSSDConnectorPosition[1]
2445 - ssdconnectorshape[0]->GetDY(),0.0);
2446 ssdconnectortrans[1] = new TGeoTranslation(
2447 - ssdstiffenershape->GetDX()
2448 + fgkSSDConnectorPosition[0]
2449 - 0.5*fgkSSDConnectorLength,
2450 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2451 - fgkSSDConnectorPosition[1]
2452 - ssdconnectorshape[0]->GetDY(),0.0);
2453 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2454 - fgkSSDConnectorPosition[0]
2455 + fgkSSDConnectorSeparation
2456 + 1.5*fgkSSDConnectorLength,
2457 -(ssdstiffenershape->GetDY()
2458 - fgkSSDConnectorPosition[1]
2459 - ssdconnectorshape[0]->GetDY()),0.0);
2460 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2461 - fgkSSDConnectorPosition[0]
2462 + 0.5*fgkSSDConnectorLength,
2463 -(ssdstiffenershape->GetDY()
2464 - fgkSSDConnectorPosition[1]
2465 - ssdconnectorshape[0]->GetDY()),0.0);
2466 for(Int_t i=0; i<kssdconnectornumber; i++) {
2467 Int_t nlay = kssdconnectorlayernumber - 1;
2468 if (i == 1 || i == 2)
2470 for(Int_t j=0; j<nlay; j++)
2471 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2473 ////////////////////////////
2474 // Capacitor 1812-330 nF
2475 ///////////////////////////
2476 // Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
2477 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
2478 0.5*fgkSSDCapacitor1812Length,
2479 0.5*fgkSSDCapacitor1812Width,
2480 0.5*fgkSSDCapacitor1812Height);
2481 // ssdcapacitor1812origin);
2482 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2483 fSSDStiffener1812CapacitorMedium);
2484 capacitor1812->SetLineColor(fColorAl);
2485 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2486 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2487 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2488 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
2490 TGeoBBox* capacitor1812capshape = new TGeoBBox("Capacitor1812CapShape",
2491 0.5*fgkSSDCapacitor1812CapLength, 0.5*fgkSSDCapacitor1812Width,
2492 0.5*fgkSSDCapacitor1812Height);
2493 TGeoVolume* capacitor1812cap = new TGeoVolume("Capacitor1812Cap",capacitor1812capshape,
2494 fSSDStiffenerCapacitorCapMedium);
2495 capacitor1812cap->SetLineColor(fColorNiSn);
2496 TGeoTranslation* capacitor1812captrans1 = new TGeoTranslation(
2497 - capacitor1812shape->GetDX() - capacitor1812capshape->GetDX(),
2498 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2499 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2500 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2501 ssdhybridcapacitormother->AddNode(capacitor1812cap,1,capacitor1812captrans1);
2502 TGeoTranslation* capacitor1812captrans2 = new TGeoTranslation(
2503 capacitor1812shape->GetDX() + capacitor1812capshape->GetDX(),
2504 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2505 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2506 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2507 ssdhybridcapacitormother->AddNode(capacitor1812cap,2,capacitor1812captrans2);
2509 ////////////////////////////
2511 ////////////////////////////
2512 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
2513 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2514 - fgkSSDConnectorSeparation;
2515 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
2516 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
2517 Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2519 Double_t wireangle = TMath::ATan(wirex/wirey);
2520 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2521 fgkSSDWireRadius, 0.5*ssdwireradius);
2522 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2523 fSSDStiffenerHybridWireMedium);
2524 hybridwire->SetLineColor(fColorPhynox);
2525 TGeoCombiTrans* hybridwirecombitrans[2];
2526 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
2527 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2528 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
2529 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
2530 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
2531 ssdstiffenershape->GetDZ()
2532 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight+fgkSSDConnectorSnHeight,
2533 new TGeoRotation("HybridWireRot1",0.,90.,0.));
2534 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
2536 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2538 new TGeoRotation("HybridWireRot2",
2539 - wireangle*TMath::RadToDeg(),0.,0.));
2540 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2541 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2542 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
2543 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2544 ssdhybridlist->Add(ssdhybridcapacitormother);
2545 /////////////////////////////////////////////////////////////
2546 // Deallocating memory
2547 /////////////////////////////////////////////////////////////
2548 delete hybridwirecombitrans[0];
2549 delete hybridwirecombitrans[1];
2550 return ssdhybridlist;
2551 /////////////////////////////////////////////////////////////
2553 ///////////////////////////////////////////////////////////////////////////////
2554 TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2555 /////////////////////////////////////////////////////////////
2556 // SSD Cooling Block System
2557 /////////////////////////////////////////////////////////////
2558 // SSD Cooling Block and Cooling Tube Transformations
2559 /////////////////////////////////////////////////////////////
2560 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2561 localcoolingblockrot->SetAngles(0.,90.,0.);
2562 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
2563 TVector3* coolingblocktransvector;
2564 coolingblocktransvector = new TVector3(fgkCoolingTubeSeparation,
2566 - 2.*fgkSSDModuleStiffenerPosition[1]
2567 - fgkSSDCoolingBlockWidth);
2568 const Int_t kcoolingblocktransnumber = 2;
2569 const Int_t kcoolingblocknumber = 4;
2570 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2571 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2572 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2573 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
2574 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2575 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X(),//+2*coolingtubedistance,
2576 j*coolingblocktransvector->Y(),
2577 - 0.5*(fgkSSDCoolingBlockHoleCenter
2578 + fgkCoolingTubeRmax));
2579 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
2582 TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
2583 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2584 /////////////////////////////////////////////////////////////
2585 // Adding Cooling block to mother volume
2586 /////////////////////////////////////////////////////////////
2587 for(Int_t i=0; i<kcoolingblocknumber; i++){
2588 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2590 /////////////////////////////////////////////////////////////
2591 // Deallocating memory
2592 /////////////////////////////////////////////////////////////
2593 delete coolingblocktransvector;
2594 delete localcoolingblockrot;
2596 return coolingsystemother;
2598 /////////////////////////////////////////////////////////////////////////////////
2599 TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
2600 /////////////////////////////////////////////////////////////
2602 /////////////////////////////////////////////////////////////
2603 const Int_t kssdflexlayernumber = 2;
2604 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2605 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2606 const Int_t kmothervertexnumber = 17;
2607 Double_t xmothervertex[kmothervertexnumber];
2608 Double_t ymothervertex[kmothervertexnumber];
2609 /////////////////////////////////////////////
2610 // Auxiliary variables for vertex positioning
2611 /////////////////////////////////////////////
2612 const Int_t kssdflexboxnumber = 5;
2613 Double_t ssdflexboxlength[kssdflexboxnumber];
2614 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
2615 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2616 * fgkSSDChipSeparationLength
2617 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2618 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
2619 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2620 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
2621 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
2622 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2623 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2624 - ssdflexboxlength[1];
2625 Double_t ssdflexboxwidth[kssdflexboxnumber];
2626 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2627 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2628 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2629 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2630 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
2631 ///////////////////////
2632 // Setting the vertices
2633 ///////////////////////
2634 xmothervertex[0] = 0.0;
2635 xmothervertex[1] = xmothervertex[0];
2636 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2637 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2638 + ssdflexboxlength[4];
2639 xmothervertex[4] = xmothervertex[3];
2640 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2641 xmothervertex[6] = xmothervertex[5];
2642 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2643 xmothervertex[8] = xmothervertex[7];
2644 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2645 xmothervertex[10] = xmothervertex[9];
2646 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2647 xmothervertex[12] = xmothervertex[11];
2648 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2649 xmothervertex[14] = xmothervertex[13];
2650 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2651 xmothervertex[16] = xmothervertex[15];
2652 ymothervertex[0] = 0.0;
2653 ymothervertex[1] = fgkSSDFlexWidth[1];
2654 ymothervertex[2] = fgkSSDFlexWidth[0];
2655 ymothervertex[3] = ymothervertex[2];
2656 ymothervertex[4] = ymothervertex[0];
2657 ymothervertex[5] = ymothervertex[4];
2658 ymothervertex[6] = ssdflexboxwidth[2];
2659 ymothervertex[7] = ymothervertex[6];
2660 ymothervertex[8] = ymothervertex[0];
2661 ymothervertex[9] = ymothervertex[8];
2662 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2663 ymothervertex[11] = ymothervertex[10];
2664 ymothervertex[12] = ymothervertex[0];
2665 ymothervertex[13] = ymothervertex[12];
2666 ymothervertex[14] = ymothervertex[7];
2667 ymothervertex[15] = ymothervertex[14];
2668 ymothervertex[16] = ymothervertex[0];
2669 /////////////////////////////////////////////////////////////
2670 // First Mother Volume containing SSDFlex
2671 /////////////////////////////////////////////////////////////
2672 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2673 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2675 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2676 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2677 TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2678 // TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2680 /////////////////////////////////////////////////////////////
2681 // SSDFlex Layer Shapes
2682 /////////////////////////////////////////////////////////////
2683 for(Int_t i=0; i<kssdflexlayernumber; i++){
2684 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2686 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2687 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2689 /////////////////////////////////////
2690 // Setting Layers into Mother Volume
2691 /////////////////////////////////////
2692 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2693 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2694 fSSDKaptonFlexMedium};
2695 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2696 "AlFlexLay2","KaptonFlexLay2"};
2697 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2698 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2699 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2700 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2701 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2702 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2703 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2704 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2705 + fgkSSDFlexHeight[1]));
2706 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2708 return ssdflexmother;
2710 /////////////////////////////////////////////////////////////////////////////////
2711 TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
2712 /////////////////////////////////////////////////////////////
2713 // Method generating SSD End Flex
2714 /////////////////////////////////////////
2715 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2716 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2717 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2718 * TMath::DegToRad()*ssdflexradiusmax
2719 - fgkSSDFlexLength[2]-TMath::Pi()
2720 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2721 - 0.1*fgkSSDFlexFullLength;
2722 const Int_t knedges = 20;
2723 const Int_t karcnumber = 2;
2724 TVector3* vertexposition[karcnumber*(knedges+1)];
2725 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2726 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2727 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2728 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2729 - 90.0*TMath::DegToRad()};
2730 TVector3* referencetrans[karcnumber];
2731 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2732 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2734 referencetrans[1] = new TVector3(referencetrans[0]->X()
2735 + fgkSSDFlexLength[2],
2736 - fgkSSDStiffenerHeight);
2737 for(Int_t i=0; i<karcnumber; i++){
2738 for(Int_t j=0; j<knedges+1; j++){
2739 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2740 radius[i]*SinD(angle[i]));
2741 angle[i] += deltangle[i]*(1.0-2.0*i);
2744 ///////////////////////
2745 // Setting the vertices
2746 ///////////////////////
2747 const Int_t kendflexlayernumber = 4;
2748 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2749 TVector3** vertex[kendflexlayernumber];
2750 for(Int_t i=0; i<kendflexlayernumber; i++)
2751 vertex[i] = new TVector3*[kendflexvertexnumber];
2752 TVector3* transvector[kendflexlayernumber+1];
2753 TVector3* deltatransvector = new TVector3();
2754 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2755 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2756 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2757 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2758 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2759 * CosD(fgkSSDFlexAngle),
2760 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2761 * SinD(fgkSSDFlexAngle),0.0);
2762 *transvector[i] = *transvector[i-1]+*deltatransvector;
2764 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2765 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2766 for(Int_t i=0; i<karcnumber; i++){
2767 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2768 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2769 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2773 for(Int_t i=0; i<kendflexlayernumber; i++){
2774 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2775 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2776 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2778 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2779 vertexposition[j]->Y()*ratioradius[0][i+1]);
2780 vertex[i][j+2]->RotateZ(referenceangle[0]);
2781 *vertex[i][j+2] += *referencetrans[0];
2782 vertex[i][4*(knedges+1)-j+1] =
2783 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2784 vertexposition[j]->Y()*ratioradius[0][i]);
2785 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2786 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2790 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2791 vertexposition[j]->Y()*ratioradius[1][i+1]);
2792 vertex[i][j+2]->RotateZ(referenceangle[1]);
2793 *vertex[i][j+2] += *referencetrans[1];
2794 vertex[i][4*(knedges+1)-j+1] =
2795 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2796 vertexposition[j]->Y()*ratioradius[1][i]);
2797 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2798 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2802 /////////////////////////////////////////////////////////////
2803 // First Mother Volume containing SSDEndFlex
2804 /////////////////////////////////////////////////////////////
2805 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2806 Double_t xmothervertex[kendflexvertexnumber];
2807 Double_t ymothervertex[kendflexvertexnumber];
2808 xmothervertex[0] = vertex[0][0]->X();
2809 ymothervertex[0] = vertex[0][0]->Y();
2810 for(Int_t i=1; i<kendflexvertexnumber; i++){
2811 if(i<2*(knedges+1)+2){
2812 xmothervertex[i] = vertex[3][i]->X();
2813 ymothervertex[i] = vertex[3][i]->Y();
2816 xmothervertex[i] = vertex[0][i]->X();
2817 ymothervertex[i] = vertex[0][i]->Y();
2820 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2821 xmothervertex,ymothervertex);
2822 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2823 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2824 // TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2825 // ssdendflexmothershape,fSSDAir);
2826 TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
2827 //////////////////////////////////////
2828 // End Flex TGeoXtru Layer Definition
2829 //////////////////////////////////////
2830 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2831 TGeoVolume* ssdendflex[kendflexlayernumber];
2832 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2833 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2834 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2835 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2836 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2837 fSSDKaptonFlexMedium};
2838 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2839 "AlEndFlexLay2","KaptonEndFlexLay2"};
2840 for(Int_t i=0; i<kendflexlayernumber; i++){
2841 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2842 xvertex[i][j] = vertex[i][j]->X();
2843 yvertex[i][j] = vertex[i][j]->Y();
2845 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2846 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2847 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2848 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2849 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2850 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2851 ssdendflexmother->AddNode(ssdendflex[i],1);
2853 /////////////////////////////////////////////////////////////
2854 // Deallocating memory
2855 /////////////////////////////////////////////////////////////
2856 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2857 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2858 for(Int_t i=0; i<kendflexlayernumber; i++){
2859 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2860 delete [] vertex[i];
2862 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2863 delete deltatransvector;
2864 /////////////////////////////////////////////////////////////
2865 //ssdendflexmother->CheckOverlaps(0.01);
2866 return ssdendflexmother;
2868 ///////////////////////////////////////////////////////////////////////////////
2869 TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
2870 /////////////////////////////////////////////////////////////
2871 // Method generating the Mounting Block
2872 /////////////////////////////////////////////////////////////
2873 const Int_t kvertexnumber = 8;
2874 Double_t xvertex[kvertexnumber];
2875 Double_t yvertex[kvertexnumber];
2876 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2877 xvertex[1] = xvertex[0];
2878 xvertex[2] = -xvertex[0];
2879 xvertex[3] = xvertex[2];
2880 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2881 - fgkSSDMountingBlockLength[2]);
2882 xvertex[5] = xvertex[4];
2883 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2884 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2885 - fgkSSDMountingBlockScrewHoleRadius[0];
2886 xvertex[7] = xvertex[6];
2887 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
2888 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
2889 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2890 yvertex[2] = yvertex[1];
2891 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2892 yvertex[4] = yvertex[3];
2893 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2894 - fgkSSDMountingBlockHeight[0];
2895 yvertex[6] = yvertex[5];
2896 yvertex[7] = yvertex[0];
2898 ///////////////////////////////////////////////////////////////////////
2899 // TGeoXTru Volume definition for Mounting Block Part
2900 ///////////////////////////////////////////////////////////////////////
2901 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2902 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2903 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2904 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
2905 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
2906 ssdmountingblockshape,
2907 fSSDMountingBlockMedium);
2908 ssdmountingblock->SetLineColor(fColorG10);
2909 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2910 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2911 TGeoRotation* mountingblockrot = new TGeoRotation();
2912 mountingblockrot->SetAngles(90.,180.,-90.);
2913 mountingblockcombitrans->SetRotation(*mountingblockrot);
2914 /////////////////////////////////////////////////////////////
2915 // Generating the Mounting Block Screw Vertices
2916 /////////////////////////////////////////////////////////////
2917 const Int_t kscrewvertexnumber = 15;
2918 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
2919 - fgkSSDMountingBlockScrewHoleEdge)
2920 / fgkSSDMountingBlockScrewHoleRadius[0])
2921 * TMath::RadToDeg();
2922 Double_t phi0 = 90.+alpha;
2923 Double_t phi = 270.-2*alpha;
2924 Double_t deltaphi = phi/kscrewvertexnumber;
2925 TVector3* screwvertex[kscrewvertexnumber+1];
2926 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
2927 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
2928 *CosD(phi0+i*deltaphi),
2929 fgkSSDMountingBlockScrewHoleRadius[0]
2930 *SinD(phi0+i*deltaphi));
2931 Double_t xscrewvertex[kscrewvertexnumber+6];
2932 Double_t yscrewvertex[kscrewvertexnumber+6];
2933 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
2934 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
2935 - fgkSSDMountingBlockScrewHoleEdge);
2936 xscrewvertex[1] = xscrewvertex[0];
2937 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2938 xscrewvertex[2] = screwvertex[0]->X();
2939 yscrewvertex[2] = yscrewvertex[1];
2940 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
2941 xscrewvertex[i+3] = screwvertex[i]->X();
2942 yscrewvertex[i+3] = screwvertex[i]->Y();
2944 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2945 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
2946 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
2947 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
2948 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
2949 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
2950 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
2951 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
2952 + fgkSSDMountingBlockHeight[2]);
2953 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
2954 ssdmountingblockscrewshape,
2955 fSSDMountingBlockMedium);
2956 ssdmountingblockscrew->SetLineColor(fColorG10);
2957 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
2958 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
2959 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2961 0.5*fgkSSDMountingBlockHeight[0]
2962 - fgkSSDMountingBlockHeight[2]
2963 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2964 + fgkSSDMountingBlockHeight[2]
2966 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2967 -0.5*fgkSSDMountingBlockScrewHoleEdge,
2969 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2970 +fgkSSDMountingBlockHeight[2]
2972 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2974 - 0.5*fgkSSDMountingBlockHeight[0]
2975 + fgkSSDMountingBlockHeight[2]
2976 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2977 + fgkSSDMountingBlockHeight[2]
2979 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2982 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2983 + fgkSSDMountingBlockHeight[2]
2985 TGeoRotation* ssdmountingblockscrewrot[4];
2986 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
2987 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
2988 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
2989 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
2990 for(Int_t i=1; i<4; i++)
2991 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
2992 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
2993 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
2994 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
2995 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
2996 + xvertex[0],yscrewvertex[1]
2997 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2998 + fgkSSDMountingBlockHeight[2]
3000 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3001 for(Int_t i=0; i<4; i++){
3002 ssdmountingblockscrewmatrix[i] =
3003 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3004 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3006 ///////////////////////////////////////////////////////////////////////
3007 // TGeoXtru for Mother Volume
3008 ///////////////////////////////////////////////////////////////////////
3009 const Int_t kvertexmothernumber = 12;
3010 Double_t xmothervertex[kvertexmothernumber];
3011 Double_t ymothervertex[kvertexmothernumber];
3012 for(Int_t i=0; i<6; i++){
3013 xmothervertex[i] = xvertex[i];
3014 ymothervertex[i] = yvertex[i];
3016 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3017 ymothervertex[6] = ymothervertex[5];
3018 xmothervertex[7] = xmothervertex[6];
3019 ymothervertex[7] = ymothervertex[4];
3020 xmothervertex[8] = xmothervertex[7]
3021 + 0.5*(fgkSSDMountingBlockLength[1]
3022 - fgkSSDMountingBlockLength[2]);
3023 ymothervertex[8] = ymothervertex[4];
3024 xmothervertex[9] = xmothervertex[8];
3025 ymothervertex[9] = ymothervertex[2];
3026 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3027 ymothervertex[10] = ymothervertex[1];
3028 xmothervertex[11] = xmothervertex[10];
3029 ymothervertex[11] = ymothervertex[0];
3030 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3031 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3032 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3033 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3034 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3035 ssdmountingblockmothershape,
3037 /////////////////////////////////////////////////////////////
3038 // Placing the Volumes into Mother Volume
3039 /////////////////////////////////////////////////////////////
3040 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3041 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3042 for(Int_t i=0; i<4; i++)
3043 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3044 ssdmountingblockscrewmatrix[i]);
3045 /////////////////////////////////////////////////////////////
3046 // Deallocating memory
3047 /////////////////////////////////////////////////////////////
3048 delete mountingblockrot;
3049 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3050 delete ssdmountingblockglobalrot;
3051 delete ssdmountingblockglobaltrans;
3052 /////////////////////////////////////////////////////////////
3053 return ssdmountingblockmother;
3055 ///////////////////////////////////////////////////////////////////////////////
3056 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3057 /////////////////////////////////////////////////////////////
3058 // Method generating the Mounting Block Clip
3059 /////////////////////////////////////////////////////////////
3060 const Int_t kmothervertexnumber = 10;
3061 Double_t xmothervertex[kmothervertexnumber];
3062 Double_t ymothervertex[kmothervertexnumber];
3063 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3064 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3065 xmothervertex[1] = xmothervertex[0];
3066 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3067 - fgkMountingBlockClibScrewRadius);
3068 xmothervertex[3] = xmothervertex[2];
3069 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3070 xmothervertex[5] = xmothervertex[4];
3071 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3072 xmothervertex[7] = xmothervertex[6];
3073 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3074 xmothervertex[9] = xmothervertex[8];
3075 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
3076 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
3077 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3078 ymothervertex[2] = ymothervertex[1];
3079 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3080 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3081 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3082 ymothervertex[4] = ymothervertex[3];
3083 ymothervertex[5] = ymothervertex[2];
3084 ymothervertex[6] = ymothervertex[5];
3085 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3086 ymothervertex[8] = ymothervertex[7];
3087 ymothervertex[9] = ymothervertex[0];
3089 ///////////////////////////////////////////////////////////////////////
3090 // TGeoXTru Volume definition for Mounting Block Clip Part
3091 ///////////////////////////////////////////////////////////////////////
3092 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3093 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3094 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3095 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3096 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3097 ssdmountingblockclipshape,fSSDAir);
3098 ssdmountingblockclip->SetLineColor(4);
3099 ///////////////////////////////////////////////////////////////////////
3100 // TGeoXTru Volume definition for Clip
3101 ///////////////////////////////////////////////////////////////////////
3102 const Int_t kclipvertexnumber = 6;
3103 Double_t xclipvertex[kclipvertexnumber];
3104 Double_t yclipvertex[kclipvertexnumber];
3105 xclipvertex[0] = xmothervertex[0];
3106 xclipvertex[1] = xclipvertex[0];
3107 xclipvertex[2] = xmothervertex[6];
3108 xclipvertex[3] = xclipvertex[2];
3109 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3110 xclipvertex[5] = xclipvertex[4];
3111 yclipvertex[0] = ymothervertex[0];
3112 yclipvertex[1] = ymothervertex[1];
3113 yclipvertex[2] = yclipvertex[1];
3114 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3115 yclipvertex[4] = yclipvertex[3];
3116 yclipvertex[5] = yclipvertex[0];
3117 TGeoXtru* clipshape = new TGeoXtru(2);
3118 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3119 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3120 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3121 + fgkMountingBlockClibWidth);
3122 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3123 clip->SetLineColor(18);
3124 ///////////////////////////////////////////////////////////////////////
3125 // Ladder Support Piece
3126 ///////////////////////////////////////////////////////////////////////
3127 const Int_t ksupportvertexnumber = 4;
3128 Double_t xsupportvertex[ksupportvertexnumber];
3129 Double_t ysupportvertex[ksupportvertexnumber];
3130 xsupportvertex[0] = xclipvertex[5];
3131 xsupportvertex[1] = xsupportvertex[0];
3132 xsupportvertex[2] = xmothervertex[9];
3133 xsupportvertex[3] = xsupportvertex[2];
3134 ysupportvertex[0] = yclipvertex[0];
3135 ysupportvertex[1] = yclipvertex[3];
3136 ysupportvertex[2] = ysupportvertex[1];
3137 ysupportvertex[3] = ysupportvertex[0];
3138 TGeoXtru* supportshape = new TGeoXtru(2);
3139 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3140 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3141 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3142 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3143 support->SetLineColor(9);
3144 ///////////////////////////////////////////////////////////////////////
3145 // TGeoXTru Volume definition for Screw
3146 ///////////////////////////////////////////////////////////////////////
3147 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3148 0.5*fgkMountingBlockClibScrewRadius};
3149 Int_t edgesnumber[2] = {50,6};
3150 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3151 +0.5*(ymothervertex[3]-ymothervertex[2])};
3152 TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3153 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3154 clipscrew->SetLineColor(12);
3155 TGeoRotation* screwrot = new TGeoRotation();
3156 screwrot->SetAngles(0.,90.,0.);
3157 TGeoTranslation* screwtrans = new TGeoTranslation();
3158 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3159 0.5*(ymothervertex[3]+ymothervertex[2]),
3160 0.5*fgkSSDMountingBlockWidth+
3161 -0.5*fgkMountingBlockSupportWidth[0]);
3162 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3163 ///////////////////////////////////////////////////////////////////////
3164 // Placing the Volumes
3165 ///////////////////////////////////////////////////////////////////////
3166 ssdmountingblockclip->AddNode(clip,1);
3167 ssdmountingblockclip->AddNode(support,1);
3168 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3169 /////////////////////////////////////////////////////////////
3170 // Deallocating memory
3171 /////////////////////////////////////////////////////////////
3174 /////////////////////////////////////////////////////////////
3175 return ssdmountingblockclip;
3177 ///////////////////////////////////////////////////////////////////////////////
3178 void AliITSv11GeometrySSD::CreateCoolingTubes() {
3179 /////////////////////////////////////////////////////////////
3180 // Method generating the Cooling Tube
3181 // sets fcoolingtube and returns list for endladdercoolingtube
3182 /////////////////////////////////////////////////////////////
3183 TGeoTube *coolingtubeshape[2];
3184 // Ladder Cooling Tubes
3186 // MvL: Simplified cooling tubes
3187 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
3188 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
3190 // End Ladder Cooling Tubes
3191 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3192 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3193 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3195 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
3196 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3197 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
3198 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3199 endladdercoolingtubeshape[0][0]->GetDz());
3200 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3201 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
3202 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3203 endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
3204 // Ladder Cooling Tubes
3205 TGeoVolume* coolingtube[2];
3206 coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
3207 coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
3208 coolingtube[0]->SetLineColor(fColorPhynox);
3209 coolingtube[1]->SetLineColor(fColorWater);
3211 // End Ladder Cooling Tubes
3212 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3213 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3214 endladdercoolingtube[i] = new TGeoVolume*[2];
3215 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3216 endladdercoolingtubeshape[0][0],
3217 fSSDCoolingTubePhynox);
3218 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3219 endladdercoolingtubeshape[0][1],
3220 fSSDCoolingTubeWater);
3221 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3222 endladdercoolingtubeshape[1][0],
3223 fSSDCoolingTubePhynox);
3224 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3225 endladdercoolingtubeshape[1][1],
3226 fSSDCoolingTubeWater);
3227 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3228 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3229 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3232 /////////////////////////////////////////////////////////////
3233 // Virtual Volume containing Cooling Tubes
3234 /////////////////////////////////////////////////////////////
3235 // Ladder Cooling Tubes
3236 TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
3237 coolingtubeshape[0]->GetRmax(),
3238 coolingtubeshape[0]->GetDz());
3239 fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
3240 fcoolingtube->AddNode(coolingtube[0],1);
3241 fcoolingtube->AddNode(coolingtube[1],1);
3243 // End Ladder Cooling Tubes
3244 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3245 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3246 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3247 endladdercoolingtubeshape[i][0]->GetRmax(),
3248 endladdercoolingtubeshape[i][0]->GetDz());
3249 fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3250 endladdervirtualcoolingtubeshape[0],
3252 fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3253 endladdervirtualcoolingtubeshape[1],
3255 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3256 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3257 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3258 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3260 ///////////////////////////////////////////////////////////////////////////////
3261 TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
3262 /////////////////////////////////////////////////////////////
3263 // Method generating SSD Cooling Block
3264 /////////////////////////////////////////////////////////////
3265 const Int_t kvertexnumber = 8;
3266 ///////////////////////////////////////
3267 // Vertex Positioning for TGeoXTru
3268 ///////////////////////////////////////
3269 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3270 vertexposition[0] = new TVector3(0.0,0.0);
3271 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3272 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3273 vertexposition[1]->Y());
3274 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3275 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3276 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3277 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3278 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3279 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3280 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3281 - fgkSSDCoolingBlockHoleLength[0]
3282 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3283 fgkSSDCoolingBlockHeight[0]
3284 - fgkSSDCoolingBlockHoleRadius[1],
3285 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3286 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3287 - fgkSSDCoolingBlockHoleLength[0]),
3288 vertexposition[6]->Y());
3289 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3290 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3291 Double_t phi = 180.-alpha;
3292 Double_t psi = 180.+2.*alpha;
3293 Double_t deltapsi = psi/nedges;
3294 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3295 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3296 fgkSSDCoolingBlockHoleCenter);
3297 for(Int_t i=0; i<nedges+1; i++){
3298 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3299 radius*SinD(phi+i*deltapsi));
3300 *vertexposition[kvertexnumber+i] += (*transvector);
3302 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3303 for(Int_t i=0; i<kvertexnumber; i++)
3304 vertexposition[kvertexnumber+nedges+1+i] =
3305 GetReflection(vertexposition[kvertexnumber-1-i],param);
3306 ///////////////////////////////////////////////////////////////////////
3307 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3308 ///////////////////////////////////////////////////////////////////////
3309 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3310 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3311 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3312 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3313 xvertexpoints[i] = vertexposition[i]->X();
3314 yvertexpoints[i] = vertexposition[i]->Y();
3316 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3318 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3319 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3320 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3321 ssdcoolingblockshape,
3322 fSSDAlCoolBlockMedium);
3323 ssdcoolingblock->SetLineColor(fColorAl);
3324 /////////////////////////////////////////////////////////////
3325 // Deallocating memory
3326 /////////////////////////////////////////////////////////////
3327 delete [] vertexposition;
3328 delete [] xvertexpoints;
3329 delete [] yvertexpoints;
3330 /////////////////////////////////////////////////////////////
3331 return ssdcoolingblock;
3333 /////////////////////////////////////////////////////////////////////////////////
3334 void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
3335 ///////////////////////////////////////////////////////
3336 static const Int_t kssdchipcablesnumber = 2; // Number of cables: left and right
3337 static const Int_t kssdchipcableslaynumber = 2; // Number of layers: Al and Kapton
3338 static const Int_t kvertexnumber = 4*(nedges+1)+4;
3339 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3340 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3341 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
3342 - fgkSSDChipCablesHeight[0]
3343 - fgkSSDChipCablesHeight[1]);
3344 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3345 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3346 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3347 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3348 - ssdchipcablesradius[0]
3349 - fgkSSDChipCablesWidth[1]
3350 - fgkSSDChipCablesWidth[2]);
3351 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3352 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3353 + fgkSSDChipCablesHeight[1]
3354 + fgkSSDSensorHeight);
3355 ///////////////////////////////////////////////////////
3356 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3357 ///////////////////////////////////////////////////////
3358 TVector3** vertexposition[kssdchipcableslaynumber];
3359 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3360 new TVector3*[4*(nedges+1)+4];
3362 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3363 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3364 / ssdchipcablesradius[0];
3365 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3366 / ssdchipcablesradius[0];
3367 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3368 + fgkSSDChipCablesHeight[1])
3369 / ssdchipcablesradius[0];
3370 Double_t phi = 180.;
3371 Double_t deltaphi = 180./nedges;
3372 Double_t angle = 0.0;
3373 Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3374 Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3375 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3376 xvertexpoints[i] = new Double_t[kvertexnumber];
3377 yvertexpoints[i] = new Double_t[kvertexnumber];
3379 TVector3* vertex = new TVector3();
3380 TVector3* transvector[kssdchipcableslaynumber];
3381 transvector[0] = new TVector3(fgkSSDChipWidth,
3382 SSDChipCablesHeight-ssdchipcablesradius[0]);
3383 transvector[1] = new TVector3();
3384 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
3385 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
3386 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
3387 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3388 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3389 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3390 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3391 transvector[1]->SetY(ssdchipcablesradius[0]
3392 + fgkSSDChipCablesHeight[0]
3393 + fgkSSDChipCablesHeight[1]);
3394 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3395 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
3396 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
3397 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
3398 - i*fgkSSDChipCablesHeight[0]);
3399 vertexposition[i][2*(nedges+1)+2] =
3400 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3401 + fgkSSDChipCablesWidth[1]
3402 + fgkSSDChipCablesWidth[2],
3403 ((1.-i)*fgkSSDChipCablesHeight[i]
3404 + fgkSSDChipCablesHeight[1]));
3405 vertexposition[i][2*(nedges+1)+3] =
3406 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3407 vertexposition[i][2*(nedges+1)+2]->Y()
3408 - fgkSSDChipCablesHeight[i]);
3409 for(Int_t j=0; j<nedges+1; j++){
3410 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3411 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3412 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3413 vertexposition[0][(nedges+1)*i+j+2] =
3414 new TVector3(*vertex+*transvector[i]);
3415 vertexposition[1][(nedges+1)*i+j+2] =
3416 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3417 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3418 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3419 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3420 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3421 new TVector3(vertex->X()*ratio[2*i+1]
3422 + transvector[i]->X(),
3423 vertex->Y()*ratio[2*i+1]
3424 + transvector[i]->Y());
3427 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3428 for(Int_t j=0; j<kvertexnumber; j++){
3429 xvertexpoints[i][j] = vertexposition[i][j]->X();
3430 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3432 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3433 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3434 xvertexpoints[i],yvertexpoints[i]);
3435 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3436 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3437 ssdchipcable[kssdchipcablesnumber*k+i] =
3438 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3439 ssdchipcableshape[kssdchipcablesnumber*k+i],
3440 (kssdchipcablesnumber*k+i)%2==0?
3441 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3442 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3444 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3445 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3447 /////////////////////////////////////////////////////////////
3448 // Mother Volume definition
3449 /////////////////////////////////////////////////////////////
3450 static const Int_t kmothervertexnumber = 8;
3451 Double_t xmothervertex[kmothervertexnumber];
3452 Double_t ymothervertex[kmothervertexnumber];
3453 xmothervertex[0] = xvertexpoints[0][1];
3454 ymothervertex[0] = yvertexpoints[0][1];
3455 xmothervertex[1] = xvertexpoints[0][2+nedges/2];
3456 ymothervertex[1] = yvertexpoints[0][1];
3457 xmothervertex[2] = xvertexpoints[0][2+nedges/2];
3458 ymothervertex[2] = yvertexpoints[0][2+nedges];
3459 xmothervertex[3] = xvertexpoints[0][3+nedges];
3460 ymothervertex[3] = yvertexpoints[0][3+nedges];
3461 xmothervertex[4] = xvertexpoints[0][3+2*nedges];
3462 ymothervertex[4] = yvertexpoints[0][3+2*nedges];
3463 xmothervertex[5] = xvertexpoints[0][4+2*nedges];
3464 ymothervertex[5] = yvertexpoints[0][4+2*nedges];
3465 xmothervertex[6] = xvertexpoints[1][5+2*nedges];
3466 ymothervertex[6] = yvertexpoints[1][5+2*nedges];
3467 xmothervertex[7] = xvertexpoints[0][1];
3468 ymothervertex[7] = yvertexpoints[1][5+2*nedges];
3469 TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
3470 ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3471 ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3472 ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3474 cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
3475 cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
3477 cableL->AddNode(ssdchipcable[0],1);
3478 cableL->AddNode(ssdchipcable[1],1);
3479 cableR->AddNode(ssdchipcable[2],1);
3480 cableR->AddNode(ssdchipcable[3],1);
3482 /////////////////////////////////////////////////////////////
3483 // Deallocating memory
3484 /////////////////////////////////////////////////////////////
3485 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3486 delete [] xvertexpoints[i];
3487 delete [] yvertexpoints[i];
3489 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3490 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3492 /////////////////////////////////////////////////////////////
3494 //_____________________________________________________________________________
3495 TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
3496 /////////////////////////////////////////////////////////////
3497 // SSD Chip Assembly Generation
3498 /////////////////////////////////////////////////////////////
3499 TGeoBBox* ssdchipcompshape[2];
3500 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3501 0.5*fgkSSDChipLength,
3502 0.5*fgkSSDChipWidth,
3503 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3504 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3505 0.5*fgkSSDChipLength,
3506 0.5*fgkSSDChipWidth,
3507 0.5*fgkSSDChipGlueHeight);
3508 TGeoVolume* ssdchipcomp[2];
3509 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3510 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3511 fSSDChipGlueMedium);
3512 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3513 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3514 TGeoTranslation* ssdchipcomptrans[2];
3515 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3516 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3517 /////////////////////////////////////////////////////////////
3518 // Virtual Volume containing SSDChip
3519 /////////////////////////////////////////////////////////////
3520 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3521 0.5*fgkSSDChipWidth,
3522 0.5*fgkSSDChipHeight);
3523 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
3524 /////////////////////////////////////////////////////////////
3525 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3528 /////////////////////////////////////////////////////////////////////////////////
3529 TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
3530 /////////////////////////////////////////////////////////////
3531 // Method returning a List containing pointers to Ladder Cable Volumes
3533 // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
3534 // each contains 2 volumes, one for polyamide and one for aluminium
3535 /////////////////////////////////////////////////////////////
3536 const Int_t kladdercablesegmentnumber = 2;
3537 /////////////////////////////////////////
3538 // LadderSegmentBBox Volume
3539 /////////////////////////////////////////
3540 static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
3541 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3542 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3545 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3546 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3547 static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3549 static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
3550 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3551 0.5*fgkSSDFlexWidth[0],
3552 0.5*fgkSSDLadderCableWidth,
3553 0.5*fgkSSDLadderCableHeight[0]),
3554 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3555 0.5*fgkSSDFlexWidth[0],
3556 0.5*fgkSSDLadderCableWidth,
3557 fgkSSDLadderCableHeight[0]
3558 +0.5*fgkSSDLadderCableHeight[1])
3560 static TGeoVolume* laddercablesegmentbboxassembly = new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
3561 static TGeoVolume* laddercablesegmentarbassembly =
3562 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3564 static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3565 static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3567 if (laddercablesegmentbboxshape[0] == 0) {
3568 // Initialise static shapes and volumes
3569 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3570 new TGeoBBox(laddercablesegmentbboxshapename[i],
3571 0.5*fgkSSDFlexWidth[0],
3572 0.5*fgkSSDLadderCableWidth,
3573 0.5*fgkSSDLadderCableHeight[i]);
3575 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3576 laddercablesegmentbbox[i] =
3577 new TGeoVolume(laddercablesegmentbboxname[i],
3578 laddercablesegmentbboxshape[i],
3579 (i==0?fSSDAlTraceLadderCableMedium:
3580 fSSDKaptonLadderCableMedium));
3581 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3585 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3586 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3587 laddercablesegmentbboxtrans[i]);
3588 /////////////////////////////////////////
3589 // LadderSegmentArb8 Volume
3590 /////////////////////////////////////////
3591 const Int_t kvertexnumber = 4;
3592 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3593 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3594 new TVector3*[kvertexnumber];
3595 //Shape Vertex Positioning
3596 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3597 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3598 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3599 i*fgkSSDFlexHeight[0]);
3600 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3601 + fgkSSDFlexHeight[1]
3602 + i*fgkSSDFlexHeight[0]);
3603 laddercablesegmentvertexposition[i][3] =
3604 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3605 laddercablesegmentvertexposition[i][2]->Y());
3607 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3608 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3609 const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3610 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3612 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3613 GetArbShape(laddercablesegmentvertexposition[i],
3614 laddercablesegmentwidth[i],
3615 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3616 laddercablesegmentarbshapename[i]);
3617 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3618 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3620 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3621 laddercablesegmentarb[i] =
3622 new TGeoVolume(laddercablesegmentarbname[i],
3623 laddercablesegmentarbshape[i],
3624 (i==0?fSSDAlTraceLadderCableMedium:
3625 fSSDKaptonLadderCableMedium));
3626 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3629 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3630 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3632 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3634 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3635 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3636 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3637 + fgkSSDFlexWidth[0],0.,0.,
3638 new TGeoRotation((*laddercablesegmentarbrot[1])
3639 *(*laddercablesegmentarbrot[0])));
3640 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3641 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3642 laddercablesegmentarbcombitrans);
3643 } // End of static initialisations
3644 /////////////////////////////////////////
3645 // End Ladder Cable Volume
3646 // Note: this part depends explicitly on the length passed as an argument to the function
3647 /////////////////////////////////////////
3648 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3649 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3650 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3651 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3652 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3653 0.5*ssdendladdercablelength,
3654 0.5*fgkSSDLadderCableWidth,
3655 0.5*fgkSSDLadderCableHeight[i]);
3656 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3657 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3658 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3659 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3660 ladderendcablesegmentbbox[i] =
3661 new TGeoVolume(ladderendcablesegmentbboxname[i],
3662 ladderendcablesegmentbboxshape[i],
3663 (i==0?fSSDAlTraceLadderCableMedium:
3664 fSSDKaptonLadderCableMedium));
3665 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3668 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3669 ladderendcablesegmentbboxtrans[0] =
3670 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
3671 0.5*ssdendladdercablelength,
3672 0.5*fgkSSDLadderCableWidth,
3673 0.5*fgkSSDLadderCableHeight[0]);
3674 ladderendcablesegmentbboxtrans[1] =
3675 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
3676 0.5*ssdendladdercablelength,
3677 0.5*fgkSSDLadderCableWidth,
3678 fgkSSDLadderCableHeight[0]
3679 +0.5*fgkSSDLadderCableHeight[1]);
3680 TGeoVolume* ladderendcablesegmentbboxassembly =
3681 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
3682 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3683 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
3684 ladderendcablesegmentbboxtrans[i]);
3685 /////////////////////////////////////////
3686 TList* laddercablesegmentlist = new TList();
3687 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
3688 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
3689 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
3690 return laddercablesegmentlist;
3693 /////////////////////////////////////////////////////////////////////////////////
3694 TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
3695 /////////////////////////////////////////////////////////////
3696 // Method generating Ladder Cable of given length (n modules + end)
3697 // Called by GetLadderCableAssembly
3698 /////////////////////////////////////////////////////////////
3699 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
3700 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
3701 for(Int_t i=0; i<n; i++){
3702 TGeoTranslation* laddercabletrans = new TGeoTranslation(
3703 i*(fgkCarbonFiberJunctionWidth),
3704 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3705 i*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
3706 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
3707 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
3710 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
3711 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3712 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3713 (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
3714 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
3717 /////////////////////////////////////////////////////////////////////////////////
3718 TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
3719 ///////////////////////////////////////////////////////////////////
3720 // Main method generating Ladder Cable bundles containing n cables
3721 ///////////////////////////////////////////////////////////////////
3722 Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
3723 Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])};
3724 TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]),cableOrig);
3725 TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
3726 char laddercabletransname[100];
3727 for(Int_t i=0; i<n; i++){
3728 sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
3729 laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
3730 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
3734 /////////////////////////////////////////////////////////////////////////////////
3735 TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
3736 /////////////////////////////////////////////////////////////
3737 // Method generating Ladder Cable List Assemblies
3738 // containing two cables bundles, i.e. P+N readout for one endcap
3739 /////////////////////////////////////////////////////////////
3740 const Int_t kladdercableassemblynumber = 2;
3741 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
3742 TGeoVolume* ladderCable[kladdercableassemblynumber];
3743 char laddercableassemblyname[100];
3744 TList* laddercableassemblylist = new TList();
3745 for(Int_t i=0; i<kladdercableassemblynumber; i++){
3746 sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
3747 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
3748 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
3749 new TGeoCombiTrans((n-1)
3750 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3751 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
3752 0.,new TGeoRotation("",180,0.,0.)));
3753 laddercableassemblylist->Add(ladderCable[i]);
3755 return laddercableassemblylist;
3757 ///////////////////////////////////////////////////////////////////////////////
3758 void AliITSv11GeometrySSD::SetLadderSegment(){
3759 /////////////////////////////////////////////////////////////
3760 // Method Generating Ladder Segment Array
3761 /////////////////////////////////////////////////////////////
3762 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
3763 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
3765 /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
3766 TGeoXtru *laddersegmentshape = new TGeoXtru(2);
3767 static const Int_t ntrianglevtx = 3;
3768 Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
3769 Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
3770 laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
3771 laddersegmentshape->DefineSection(0,0);
3772 laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth); // MVL
3773 fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
3774 fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
3777 if(!fCreateMaterials) CreateMaterials();
3778 if(!fTransformationMatrices) CreateTransformationMatrices();
3779 if(!fBasicObjects) CreateBasicObjects();
3780 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
3781 // Placing Carbon Fiber Support
3782 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
3783 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3784 fcarbonfibersupportmatrix[j]);
3785 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3786 fcarbonfibersupportmatrix[j]);
3788 // Placing Carbon Fiber Junction
3789 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
3790 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
3791 fcarbonfiberjunctionmatrix[j]);
3793 // Placing Carbon Fiber Lower Support
3794 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
3795 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
3796 fcarbonfiberlowersupportrans[j]);
3798 // Placing SSD Sensor Support
3799 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
3800 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
3801 fssdsensorsupport[1][i],
3802 j+1,fssdsensorsupportmatrix[j]);
3803 // Placing SSD Cooling Tube Support
3804 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
3805 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3806 fcoolingtubesupportmatrix[j]);
3807 // Placing SSD Cooling Tube
3808 fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
3809 fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
3810 // Placing SSD Hybrid
3813 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
3814 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3817 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
3818 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3821 // Placing Cooling Block System
3822 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
3824 for(Int_t j=0; j<fgkflexnumber; j++){
3825 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
3826 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
3830 ///////////////////////////////////////////////////////////////////////////////
3831 void AliITSv11GeometrySSD::SetEndLadderSegment(){
3832 /////////////////////////////////////////////////////////////
3833 // Method Generating End Ladder
3834 /////////////////////////////////////////////////////////////
3835 // End Ladder Carbon Fiber Junction
3836 /////////////////////////////////////////////////////////////
3837 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
3838 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
3839 if(!fCreateMaterials) CreateMaterials();
3840 if(!fTransformationMatrices) CreateTransformationMatrices();
3841 if(!fBasicObjects) CreateBasicObjects();
3842 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
3843 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
3844 fendladdersegment[i]->AddNode(j==2 ?
3845 fendladdercarbonfiberjunction[i][1] :
3846 fendladdercarbonfiberjunction[i][0],
3847 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
3849 /////////////////////////////////////////////////////////////
3850 // End Ladder Carbon Fiber Support
3851 /////////////////////////////////////////////////////////////
3852 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
3853 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
3854 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3855 fendladdercarbonfibermatrix[i][j]);
3856 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3857 fendladdercarbonfibermatrix[i][j]);
3859 /////////////////////////////////////////////////////////////
3860 // End Ladder Mounting Block
3861 /////////////////////////////////////////////////////////////
3862 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3863 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
3864 fendladdermountingblockcombitrans[i]);
3865 /////////////////////////////////////////////////////////////
3866 // End Ladder Mounting Block Clip
3867 /////////////////////////////////////////////////////////////
3868 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3869 for(Int_t j=0; j<2; j++)
3870 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
3871 fendladdermountingblockclipmatrix[i][j]);
3872 /////////////////////////////////////////////////////////////
3873 // End Ladder Lower Supports
3874 /////////////////////////////////////////////////////////////
3875 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
3876 fendladderlowersupptrans[0]);
3877 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
3878 fendladderlowersupptrans[1]);
3879 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
3880 fendladderlowersupptrans[2]);
3881 /////////////////////////////////////////////////////////////
3882 // End Ladder Cooling Tube Support
3883 /////////////////////////////////////////////////////////////
3884 for(Int_t i=0; i<2; i++)
3885 for(Int_t j=0; j<(i==0?4:2); j++)
3886 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3887 fendladdercoolingtubesupportmatrix[i][j]);
3888 /////////////////////////////////////////////////////////////
3889 // End Ladder Cooling Tube Support
3890 /////////////////////////////////////////////////////////////
3891 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
3892 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
3893 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
3894 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
3896 ///////////////////////////////////////////////////////////////////////////////
3897 void AliITSv11GeometrySSD::SetLadder(){
3898 /////////////////////////////////////////////////////////////
3899 // Method Generating Ladder of Layer 5 and 6
3900 /////////////////////////////////////////////////////////////
3901 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
3902 fgkSSDLay6SensorsNumber};
3903 /////////////////////////////////////////////////////////////////////////////
3904 /// Generating Ladder Mother Volume Containing Ladder
3905 /////////////////////////////////////////////////////////////////////////////
3906 TGeoXtru* laddershape[fgkladdernumber];
3907 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
3908 const Int_t kmothervertexnumber = 8;
3909 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
3910 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
3911 ///////////////////////
3912 // Setting the vertices
3913 ///////////////////////
3914 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
3915 * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]);
3916 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
3917 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
3918 xmothervertex[0][1] = xmothervertex[0][0];
3919 ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010
3920 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
3921 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
3922 ymothervertex[0][2] = ymothervertex[0][1];
3923 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
3924 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
3925 xmothervertex[0][4] = -xmothervertex[0][3];
3926 ymothervertex[0][4] = ymothervertex[0][3];
3927 xmothervertex[0][5] = -xmothervertex[0][2];
3928 ymothervertex[0][5] = ymothervertex[0][2];
3929 xmothervertex[0][6] = -xmothervertex[0][1];
3930 ymothervertex[0][6] = ymothervertex[0][1];
3931 xmothervertex[0][7] = -xmothervertex[0][0];
3932 ymothervertex[0][7] = ymothervertex[0][0];
3933 for(Int_t i=0; i<kmothervertexnumber; i++){
3934 xmothervertex[1][i] = xmothervertex[0][i];
3935 ymothervertex[1][i] = ymothervertex[0][i];
3937 ///////////////////////////////////////////////////////////////////////////
3938 // Disalignement Mother Volume corrections 25/08/08
3939 ///////////////////////////////////////////////////////////////////////////
3940 TGeoXtru* leftladdershape1[fgkladdernumber];
3941 TGeoXtru* leftladdershape2[fgkladdernumber];
3942 TGeoXtru* centersensorladdershape[fgkladdernumber];
3943 TGeoXtru* rightladdershape1[fgkladdernumber];
3944 TGeoXtru* rightladdershape2[fgkladdernumber];
3945 for(Int_t i=0; i<fgkladdernumber; i++){
3946 leftladdershape1[i] = new TGeoXtru(2);
3947 leftladdershape2[i] = new TGeoXtru(2);
3948 centersensorladdershape[i] = new TGeoXtru(2);
3949 rightladdershape1[i] = new TGeoXtru(2);
3950 rightladdershape2[i] = new TGeoXtru(2);
3952 //////////////////////////////////////
3953 // Setting the names for shapes
3954 //////////////////////////////////////
3955 leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
3956 leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
3957 leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
3958 leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
3959 centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
3960 centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
3961 rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
3962 rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
3963 rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
3964 rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
3965 //////////////////////////////////////
3966 Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
3967 Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
3968 Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
3969 Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
3970 Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
3971 Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
3972 for(Int_t i=0; i<fgkladdernumber; i++) {
3973 for(Int_t j=0; j<kmothervertexnumber; j++){
3974 xcentersensorvertex[i][j] = xmothervertex[i][j];
3975 ycentersensorvertex[i][j] = ymothervertex[i][j];
3976 xend1laddervertex[i][j] = xmothervertex[i][j];
3977 yend1laddervertex[i][j] = ymothervertex[i][j];
3978 xend2laddervertex[i][j] = xmothervertex[i][j];
3979 yend2laddervertex[i][j] = ymothervertex[i][j];
3981 // Add some space around sensors to accommodate misalignments
3982 xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
3983 xcentersensorvertex[i][1] = xcentersensorvertex[0][0];
3984 xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
3985 xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
3987 ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
3988 ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
3990 // Center Ladder Piece
3991 centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
3992 ycentersensorvertex[i]);
3993 centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3994 + 1.45*fgkSSDMountingBlockWidth);
3995 centersensorladdershape[i]->DefineSection(1, ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
3996 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
3997 - 2.4*fgkSSDMountingBlockWidth);
3999 // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
4001 // Cuts off first corner (neg x)
4002 xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4003 xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
4004 // Cuts off last part (pos x)
4005 xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
4006 xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
4008 leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4009 yend1laddervertex[i]);
4010 leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4011 leftladdershape1[i]->DefineSection(1, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4012 - fgkEndLadderMountingBlockPosition[0]);
4014 leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4015 yend2laddervertex[i]);
4016 leftladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4017 - fgkEndLadderMountingBlockPosition[0]);
4018 leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
4019 + 1.45*fgkSSDMountingBlockWidth); // connect to main volume at -1.6725 cm
4021 rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4022 yend1laddervertex[i]);
4023 rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4024 +fgkEndLadderCarbonFiberLowerJunctionLength[0]
4025 -2.4*fgkSSDMountingBlockWidth);
4026 rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4027 + fgkEndLadderMountingBlockPosition[1]);
4029 rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4030 yend2laddervertex[i]);
4031 rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4032 + fgkEndLadderMountingBlockPosition[1]);
4033 rightladdershape2[i]->DefineSection(1, ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4034 + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4036 TGeoCompositeShape* laddershapecontainer[2];
4037 laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4038 "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4039 "+Lay5CenterSensorContainer"
4040 "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4041 laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4042 "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4043 "+Lay6CenterSensorContainer"
4044 "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4045 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4046 for(Int_t i=0; i<fgkladdernumber; i++){
4047 fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4048 fladder[i]->SetLineColor(4);
4050 ///////////////////////////////////////////////////////////////////////////
4051 if(!fCreateMaterials) CreateMaterials();
4052 if(!fTransformationMatrices) CreateTransformationMatrices();
4053 if(!fBasicObjects) CreateBasicObjects();
4055 SetEndLadderSegment();
4056 for(Int_t i=0; i<fgkladdernumber; i++){
4057 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4058 //////////////////////////
4059 /// Placing Ladder Segment
4060 //////////////////////////
4061 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4062 fladdersegment[i==0 ? 1 : 0],
4063 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4064 //////////////////////////
4065 /// Placing SSD Sensor
4066 //////////////////////////
4067 if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
4068 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4069 fssdsensormatrix[i][j]);
4071 ///////////////////////////////
4072 /// Placing End Ladder Segment
4073 ///////////////////////////////
4074 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4075 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4077 /////////////////////////////////////////////////////////////////////////////
4078 /// Placing Ladder Cables
4079 /////////////////////////////////////////////////////////////////////////////
4080 Int_t sidecablenumber[2][2];
4081 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4082 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4083 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4084 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4085 Double_t carbonfibertomoduleposition[3];
4086 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4087 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4088 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4089 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4090 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4091 - fgkSSDSensorCenterSupportThickness[0]);
4092 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4093 + 0.5*fgkCoolingTubeSupportHeight
4094 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4095 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
4096 Double_t ssdendladdercablelength[4];
4097 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
4098 + fgkSSDSensorLength
4099 - fgkSSDModuleStiffenerPosition[1]
4100 - fgkSSDStiffenerWidth
4101 - fgkSSDFlexWidth[0]
4102 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4103 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
4104 + fgkSSDModuleStiffenerPosition[1]
4105 + fgkSSDStiffenerWidth
4106 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
4107 ssdendladdercablelength[2] = ssdendladdercablelength[1]
4108 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
4109 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4110 - kendladdercablecorrection;
4111 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4112 + carbonfibertomoduleposition[1]
4113 - fgkSSDModuleStiffenerPosition[1]
4114 - fgkSSDStiffenerWidth)
4115 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
4117 TList* laddercableassemblylist[4];
4118 const Int_t kendladdercablesnumber = 4;
4119 TGeoRotation *laddercablerot = new TGeoRotation();
4120 laddercablerot->SetAngles(90.,60.,-90.);
4121 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4122 for(Int_t j=0; j<kendladdercablesnumber; j++){
4123 laddercableassemblylist[j] =
4124 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4125 ssdendladdercablelength[j]);
4126 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4127 j<2?1:2,fladdercablematrix[i][j]);
4130 ////////////////////////////////////////////////////////////////////////////////
4131 void AliITSv11GeometrySSD::SetLayer(){
4132 ////////////////////////////////////////////////////////////////////////////////
4133 // Creating Ladder of Layer 5 and Layer 6
4134 /////////////////////////////////////////////////////////////
4135 if(!fCreateMaterials) CreateMaterials();
4136 if(!fTransformationMatrices) CreateTransformationMatrices();
4137 if(!fBasicObjects) CreateBasicObjects();
4138 SetLadder(); // Generating the ladder of Layer5 and Layer6
4139 const Int_t kssdlayladdernumber[fgklayernumber] =
4140 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4141 /////////////////////////////////////////////////////////////
4142 // Generating mother volumes for Layer5 and Layer6
4143 /////////////////////////////////////////////////////////////
4144 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4145 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
4146 Int_t *ladderindex[fgklayernumber];
4147 Int_t index[fgklayernumber] = {8,9};
4148 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4149 for(Int_t i=0; i<fgklayernumber; i++)
4150 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4151 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4152 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4153 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4154 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4156 /////////////////////////////////////////////////////////////
4157 // Deallocating memory
4158 /////////////////////////////////////////////////////////////
4159 for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
4161 ////////////////////////////////////////////////////////////////////////////////
4162 void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
4163 /////////////////////////////////////////////////////////////
4164 // Insert the layer 5 in the mother volume.
4165 /////////////////////////////////////////////////////////////
4167 AliError("Can't insert layer5, mother is null!\n");
4170 if(!fSSDLayer5) SetLayer();
4172 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4173 + fgkLay5CenterITSPosition);
4174 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
4176 ////////////////////////////////////////////////////////////////////////////////
4177 void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
4178 /////////////////////////////////////////////////////////////
4179 // Insert the layer 6 in the mother volume.
4180 /////////////////////////////////////////////////////////////
4182 AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4185 if(!fSSDLayer6) SetLayer();
4187 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4188 + fgkLay6CenterITSPosition);
4189 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
4191 ////////////////////////////////////////////////////////////////////////////////
4192 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4193 /////////////////////////////////////////////////////////////
4194 // Method generating the Arc structure of Ladder Support
4195 /////////////////////////////////////////////////////////////
4196 const Int_t kssdlayladdernumber[fgklayernumber] =
4197 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4198 Double_t mountingsupportedge[fgklayernumber];
4199 Double_t mountingblockratio[fgklayernumber];
4200 Double_t theta[fgklayernumber];
4201 Double_t phi[fgklayernumber];
4202 Double_t psi0[fgklayernumber];
4203 Double_t deltapsi[fgklayernumber];
4204 TVector3* mountingsupportedgevector[fgklayernumber];
4205 for(Int_t i=0; i<fgklayernumber; i++){
4206 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4207 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4208 * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
4209 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4210 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4211 / kssdlayladdernumber[i])));
4212 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4213 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4214 mountingsupportedgevector[i] = new TVector3();
4215 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4216 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4217 (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4218 (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
4219 psi0[i] = 0.5*TMath::Pi()-phi[i];
4220 deltapsi[i] = (theta[i]+phi[i])/nedges;
4222 TVector3** vertex[fgklayernumber];
4223 TList* vertexlist[fgklayernumber];
4224 Int_t indexedge[fgklayernumber] = {0,0};
4225 for(Int_t i=0; i<fgklayernumber; i++){
4226 vertex[i] = new TVector3*[nedges+1];
4227 vertexlist[i] = new TList();
4229 for(Int_t i=0; i<fgklayernumber; i++){
4230 for(Int_t j=0; j<nedges+1; j++){
4231 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4232 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4233 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4234 vertexlist[i]->Add(vertex[i][j]);
4236 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4238 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4239 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4240 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4241 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4242 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4243 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4244 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4245 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4246 for(Int_t i=0; i<fgklayernumber; i++){
4247 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4248 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4249 xcentervertex[i] = new Double_t[indexedge[i]+3];
4250 ycentervertex[i] = new Double_t[indexedge[i]+3];
4251 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4252 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4253 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4254 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4255 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4256 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4257 ((TVector3*)vertexlist[i]->At(j))->X();
4258 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4259 ((TVector3*)vertexlist[i]->At(j))->Y();
4260 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4261 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4262 if(j<indexedge[i]+1){
4263 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4264 ((TVector3*)vertexlist[i]->At(j))->X();
4265 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4266 ((TVector3*)vertexlist[i]->At(j))->Y();
4267 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4268 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4271 xsidevertex[i][1] = xsidevertex[i][0];
4272 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4273 xsidevertex[i][2] = xsidevertex[i][3];
4274 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4275 xcentervertex[i][1] = xcentervertex[i][0];
4276 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4277 xcentervertex[i][2] = xcentervertex[i][3];
4278 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4279 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4280 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4281 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4282 ycenterlowervertex[i][0] = ysidevertex[i][0];
4283 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4284 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4286 /////////////////////////////////////////////////////////////
4287 // Building the Arc Structure of Ladder Supports
4288 /////////////////////////////////////////////////////////////
4289 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4290 TGeoXtru* centermountingsupportshape[fgklayernumber];
4291 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4292 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4293 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4294 TGeoVolume* centermountingblocksupport[fgklayernumber];
4295 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4296 TGeoVolume* centerladdersupportpiece[fgklayernumber];
4297 char sidemountingblockname[100];
4298 char centermountingblockname[100];
4299 char sideladdersupportpiecename[100];
4300 char centerladdersupportpiecename[100];
4301 for(Int_t i=0; i<fgklayernumber; i++){
4302 sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4303 sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4304 sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4305 sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4306 sidemountingblocksupportshape[i] = new TGeoXtru(2);
4307 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4308 xsidevertex[i],ysidevertex[i]);
4309 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4310 -fgkMountingBlockSupportWidth[0]);
4311 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4312 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4313 sidemountingblocksupportshape[i],
4314 fSSDAlCoolBlockMedium);
4315 sidemountingblocksupport[i]->SetLineColor(9);
4316 centermountingsupportshape[i] = new TGeoXtru(2);
4317 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4318 xcentervertex[i],ycentervertex[i]);
4319 centermountingsupportshape[i]->DefineSection(0,0.);
4320 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4321 -fgkMountingBlockSupportWidth[0]);
4323 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4324 centermountingsupportshape[i],
4325 fSSDAlCoolBlockMedium);
4326 centermountingblocksupport[i]->SetLineColor(9);
4327 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4328 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4329 xsidelowervertex[i],ysidelowervertex[i]);
4330 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4331 -fgkMountingBlockSupportWidth[0]);
4332 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4333 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4334 sideladdersupportpieceshape[i],
4335 fSSDCarbonFiberMedium);
4336 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4337 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4338 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4339 xcenterlowervertex[i],ycenterlowervertex[i]);
4340 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4341 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4342 -fgkMountingBlockSupportWidth[0]);
4343 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4344 centerladdersupportpieceshape[i],
4345 fSSDCarbonFiberMedium);
4346 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4348 /////////////////////////////////////////////////////////////
4349 // Building the Up Structure of Ladder Supports
4350 /////////////////////////////////////////////////////////////
4351 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4352 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4353 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4354 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4355 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4356 //////////////////////////////////////////////////////////
4357 // Setting the volume for TGeoXtru Mounting Block Piece
4358 //////////////////////////////////////////////////////////
4359 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4360 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4361 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4362 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4363 TGeoVolume* mountingblockpieceup[fgklayernumber];
4364 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4365 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4366 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4367 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
4368 char mountingblockpiecedownname[100];
4369 char mountingblockpieceupname[100];
4370 for(Int_t i=0; i<fgklayernumber; i++){
4371 ///////////////////////////
4372 // Mounting Block Down Vertex
4373 ///////////////////////////
4374 mountingblockpiecedownshape[i] = new TGeoXtru(2);
4375 sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4376 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4377 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4378 + fgkMountingBlockSupportDownHeight
4379 - fgkSSDLadderVerticalDisalignment;
4380 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4381 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4382 + fgkSSDMountingBlockHeight[1]
4383 - 0.5*fgkCoolingTubeSupportHeight
4384 - fgkSSDModuleCoolingBlockToSensor;
4385 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4386 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4387 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4388 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4389 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4390 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4391 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4392 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4393 + fgkSSDMountingBlockHeight[2]
4394 - fgkSSDMountingBlockHeight[0];
4395 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4396 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4397 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4398 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4399 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4400 mountingblockpiecedownyvertex[i]);
4401 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4402 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4403 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
4404 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
4405 mountingblockpiecedown[i]->SetLineColor(fColorG10);
4407 ///////////////////////////
4408 // Mounting Block Up Vertex
4409 ///////////////////////////
4410 mountingblockpieceupshape[i] = new TGeoXtru(2);
4411 sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4412 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4413 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4414 + fgkMountingBlockSupportUpHeight[i]
4415 - fgkSSDLadderVerticalDisalignment;
4416 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4417 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4418 + fgkSSDMountingBlockHeight[1]
4419 - 0.5*fgkCoolingTubeSupportHeight
4420 - fgkSSDModuleCoolingBlockToSensor;
4421 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4422 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4423 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4424 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4425 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4426 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4427 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4428 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4429 + fgkSSDMountingBlockHeight[2]
4430 - fgkSSDMountingBlockHeight[0];
4431 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4432 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4433 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4434 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4436 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4437 mountingblockpieceupyvertex[i]);
4438 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4439 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4440 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
4441 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
4442 mountingblockpieceup[i]->SetLineColor(fColorG10);
4444 ///////////////////////////////////////////////////////////////////
4445 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4446 ///////////////////////////////////////////////////////////////////
4447 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4448 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4449 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4450 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4451 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4452 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4453 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4454 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4455 char mountingblocksupportrapezoidowname[100];
4456 char mountingblocksupportrapezoidupname[100];
4457 Double_t scalefactor = 3./4.;
4458 for(Int_t i=0; i<fgklayernumber; i++){
4459 ////////////////////////////////////////////
4460 // Mounting Block Support Down Trapezoid Vertex
4461 ////////////////////////////////////////////
4462 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4463 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4464 - mountingsupportedge[i];
4465 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4466 mountingblocksupportrapezoidownxvertex[i][1] =
4467 mountingblocksupportrapezoidownxvertex[i][0];
4468 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4469 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4470 - mountingblockpiecedownyvertex[i][0]);
4471 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4472 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4473 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4474 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4475 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4476 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4478 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4479 mountingblocksupportrapezoidownyvertex[i]);
4480 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4481 -fgkMountingBlockSupportWidth[0]);
4482 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4483 sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4484 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
4485 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
4486 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4487 ////////////////////////////////////////////
4488 // Mounting Block Support Up Trapezoid Vertex
4489 ////////////////////////////////////////////
4490 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4491 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4492 - mountingsupportedge[i];
4493 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4494 mountingblocksupportrapezoidupxvertex[i][1] =
4495 mountingblocksupportrapezoidupxvertex[i][0];
4496 mountingblocksupportrapezoidupyvertex[i][1] =
4497 mountingblockpieceupyvertex[i][0]
4498 + scalefactor*(mountingblockpieceupyvertex[i][1]
4499 - mountingblockpieceupyvertex[i][0]);
4500 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4501 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4502 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4503 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4504 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4505 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4507 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4508 mountingblocksupportrapezoidupyvertex[i]);
4509 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4510 -fgkMountingBlockSupportWidth[0]);
4511 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4512 sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4513 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
4514 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
4515 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4517 ///////////////////////////////////////////////////////////////////
4518 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4519 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4520 Double_t boxoriginup[fgklayernumber][2][3];
4521 Double_t boxorigindown[fgklayernumber][2][3];
4522 char mountingblocksupportboxdownname[100];
4523 char mountingblocksupportboxupname[100];
4524 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4525 mountingblocksupportrot->SetAngles(90.,180.,-90);
4526 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4527 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4528 TGeoHMatrix* laddersupportmatrix[2];
4529 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4530 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4531 /////////////////////////////////////////////////////////////
4532 // Creating Mother Volume for Containment
4533 /////////////////////////////////////////////////////////////
4534 Double_t *xmothervertex[fgklayernumber];
4535 Double_t *ymothervertex[fgklayernumber];
4536 for(Int_t i=0; i<fgklayernumber; i++){
4537 xmothervertex[i] = new Double_t[8];
4538 ymothervertex[i] = new Double_t[8];
4540 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4541 TGeoVolume* downmotherladdersupport[fgklayernumber];
4542 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4543 TGeoVolume* upmotherladdersupport[fgklayernumber];
4544 char upmotheladdersupportname[100];
4545 char downmotheladdersupportname[100];
4546 for(Int_t i=0; i<fgklayernumber; i++){
4547 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4548 - mountingsupportedge[i];
4549 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4550 xmothervertex[i][1] = xmothervertex[i][0];
4551 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4552 + fgkMountingBlockSupportWidth[0];
4553 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4554 ymothervertex[i][2] = ymothervertex[i][1];
4555 xmothervertex[i][3] = xmothervertex[i][2];
4556 ymothervertex[i][3] = -ymothervertex[i][0];
4557 xmothervertex[i][4] = -xmothervertex[i][0];
4558 ymothervertex[i][4] = ymothervertex[i][3];
4559 xmothervertex[i][5] = xmothervertex[i][4];
4560 ymothervertex[i][5] = -ymothervertex[i][1];
4561 xmothervertex[i][6] = -xmothervertex[i][2];
4562 ymothervertex[i][6] = ymothervertex[i][5];
4563 xmothervertex[i][7] = xmothervertex[i][6];
4564 ymothervertex[i][7] = ymothervertex[i][0];
4566 sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4567 sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
4569 downmotherladdersupportshape[i] = new TGeoXtru(2);
4570 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4571 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4572 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4573 + fgkMountingBlockSupportDownHeight
4574 + fgkSSDMountingBlockHeight[1]
4575 - 0.5*fgkCoolingTubeSupportHeight
4576 - fgkSSDModuleCoolingBlockToSensor
4577 - fgkSSDLadderVerticalDisalignment);
4579 // - fgkSSDModuleVerticalDisalignment);
4580 //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4582 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4583 downmotherladdersupportshape[i],fSSDAir);
4584 upmotherladdersupportshape[i] = new TGeoXtru(2);
4585 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4586 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4587 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4588 + fgkMountingBlockSupportUpHeight[i]
4589 + fgkSSDMountingBlockHeight[1]
4590 - 0.5*fgkCoolingTubeSupportHeight
4591 - fgkSSDModuleCoolingBlockToSensor
4592 - fgkSSDLadderVerticalDisalignment);
4594 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4595 upmotherladdersupportshape[i],fSSDAir);
4597 for(Int_t i=0; i<fgklayernumber; i++){
4598 /////////////////////////
4599 // Setting the box origin
4600 /////////////////////////
4601 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4602 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
4603 + 0.5*fgkMountingBlockSupportDownHeight
4604 - 0.5*fgkSSDLadderVerticalDisalignment;
4605 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4606 - 0.5*fgkMountingBlockSupportWidth[0];
4608 boxorigindown[i][1][0] = 0.0;
4609 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4610 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4611 - fgkMountingBlockSupportWidth[0]);
4613 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4614 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4615 + 0.5*fgkMountingBlockSupportUpHeight[i]
4616 - 0.5*fgkSSDLadderVerticalDisalignment;
4617 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4618 - 0.5*fgkMountingBlockSupportWidth[0];
4620 boxoriginup[i][1][0] = 0.0;
4621 boxoriginup[i][1][1] = boxoriginup[i][0][1];
4622 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4623 - fgkMountingBlockSupportWidth[0]);
4625 /////////////////////////
4626 // Setting the boxes
4627 /////////////////////////
4628 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4629 + fgkSSDMountingBlockLength[0]),
4630 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
4631 0.5*fgkMountingBlockSupportWidth[0],
4632 boxorigindown[i][0]);
4633 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4634 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
4635 0.5*(fgkMountingBlockSupportWidth[1]
4636 - fgkMountingBlockSupportWidth[0]),
4637 boxorigindown[i][1]);
4639 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4640 + fgkSSDMountingBlockLength[0]),
4641 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
4642 0.5*fgkMountingBlockSupportWidth[0],
4645 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4646 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
4647 0.5*(fgkMountingBlockSupportWidth[1]
4648 - fgkMountingBlockSupportWidth[0]),
4650 ///////////////////////////////////////
4651 // Adding the Volumes to Mother Volume
4652 ///////////////////////////////////////
4653 for(Int_t j=0; j<2; j++){
4654 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4655 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4656 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4657 mountingblocksupportboxdownshape[i][j],
4658 fSSDCarbonFiberMedium);
4659 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4660 mountingblocksupportboxupshape[i][j],
4661 fSSDCarbonFiberMedium);
4662 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4663 mountingblocksupportboxup[i][j]->SetLineColor(9);
4664 for(Int_t k=0; k<2; k++){
4665 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4666 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4669 for(Int_t k=0; k<2; k++){
4670 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4671 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4672 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4673 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4674 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4675 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4676 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4677 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4678 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4679 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4680 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4681 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
4684 TList* laddersupportlist = new TList();
4685 laddersupportlist->Add(downmotherladdersupport[0]);
4686 laddersupportlist->Add(upmotherladdersupport[0]);
4687 laddersupportlist->Add(downmotherladdersupport[1]);
4688 laddersupportlist->Add(upmotherladdersupport[1]);
4689 /////////////////////////////////////////////////////////////
4690 // Deallocating memory
4691 /////////////////////////////////////////////////////////////
4692 for(Int_t i=0; i<fgklayernumber; i++){
4693 for(Int_t j=0; j<nedges+1; j++)
4694 delete vertex[i][j];
4695 delete mountingsupportedgevector[i];
4696 delete [] vertex[i];
4697 delete vertexlist[i];
4698 delete [] xsidevertex[i];
4699 delete [] ysidevertex[i];
4700 delete [] xcentervertex[i];
4701 delete [] ycentervertex[i];
4702 delete [] xsidelowervertex[i];
4703 delete [] ysidelowervertex[i];
4704 delete [] xcenterlowervertex[i];
4705 delete [] ycenterlowervertex[i];
4706 delete [] xmothervertex[i];
4707 delete [] ymothervertex[i];
4709 delete [] xsidevertex;
4710 delete [] ysidevertex;
4711 delete [] xcentervertex;
4712 delete [] ycentervertex;
4713 delete [] xsidelowervertex;
4714 delete [] ysidelowervertex;
4715 delete [] xcenterlowervertex;
4716 delete [] ycenterlowervertex;
4717 delete globalrefladdersupportrot;
4718 delete mountingblocksupportrot;
4719 /////////////////////
4720 return laddersupportlist;
4722 ////////////////////////////////////////////////////////////////////////////////
4723 void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4724 //////////////////////////////////////////
4725 // Method Generating Ladder Support Ring
4726 //////////////////////////////////////////
4727 if(!fCreateMaterials) CreateMaterials();
4728 if(!fTransformationMatrices) CreateTransformationMatrices();
4729 if(!fBasicObjects) CreateBasicObjects();
4730 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4731 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4732 const Int_t kssdlayladdernumber[fgklayernumber] =
4733 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4734 Double_t mountingsupportedge[fgklayernumber];
4735 Double_t mountingblockratio[fgklayernumber];
4736 Double_t theta[fgklayernumber];
4737 Double_t phi[fgklayernumber];
4738 for(Int_t i=0; i<fgklayernumber; i++){
4739 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4740 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4741 *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
4742 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4743 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4744 / kssdlayladdernumber[i])));
4745 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4746 / fgkMountingBlockSupportRadius[i]);
4747 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4749 TGeoRotation* globalrot = new TGeoRotation();
4750 globalrot->SetAngles(0.,-90.,0.);
4751 TGeoRotation** laddersupportrot[fgklayernumber];
4752 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4753 for(Int_t i=0; i<fgklayernumber; i++){
4754 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4755 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4756 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4757 laddersupportrot[i][j] = new TGeoRotation();
4758 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4760 case 0: //Ladder of Layer5
4761 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4762 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4763 laddersupportmatrix[i][j]);
4765 case 1: //Ladder of Layer6
4766 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4767 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4768 laddersupportmatrix[i][j]);
4773 /////////////////////////////////////////////////////////////
4774 // Creating Lower Ladder Support
4775 /////////////////////////////////////////////////////////////
4776 TVector3** ringsupportvertex[fgklayernumber];
4777 Double_t angle = 360./nedges;
4778 for(Int_t i=0; i<fgklayernumber; i++){
4779 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4780 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4781 * TMath::Cos(theta[i]));
4782 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4783 - mountingsupportedge[i],
4784 ringsupportvertex[i][0]->Y());
4785 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4786 ringsupportvertex[i][1]->Y());
4787 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4788 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4789 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4790 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4791 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4792 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4794 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4795 for(Int_t j=0; j<nedges+1; j++){
4796 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
4797 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
4798 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle));
4801 Double_t **xmothervertex = new Double_t*[fgklayernumber];
4802 Double_t **ymothervertex = new Double_t*[fgklayernumber];
4803 for(Int_t i=0; i<fgklayernumber; i++){
4804 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4805 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4806 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4807 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4808 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4811 ////////////////////////////////////////////////////////////////////////////////
4812 // Start Corrections 13/06/08
4813 ////////////////////////////////////////////////////////////////////////////////
4814 char lowerladderpconsupportname[100];
4815 TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4816 TGeoVolume* lowerladderpconsupport[fgklayernumber];
4817 Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4818 Double_t lowerladderpconradiusmax[fgklayernumber];
4819 Double_t lowerladderpconradiusmin[fgklayernumber];
4820 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4821 lowerladdersupportrot->SetAngles(90.,180.,-90);
4822 for(Int_t i=0; i<fgklayernumber; i++){
4823 lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4824 * TMath::Cos(theta[i]);
4825 lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
4827 for(Int_t i=0; i<fgklayernumber; i++){
4828 /////////////////////////// Modified Version ?///////////////////
4829 lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4830 for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
4831 lowerladderpconezsection[j],lowerladderpconradiusmin[i],
4832 lowerladderpconradiusmax[i]);
4833 sprintf(lowerladderpconsupportname,"LowerLadderPConSupportNameLay%d",i+5);
4834 lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
4835 lowerladderpconsupport[i]->SetLineColor(fColorAl);
4836 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
4837 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
4839 ////////////////////////////////////////////////////////////////////////////////
4840 // End Corrections 13/06/08
4841 ////////////////////////////////////////////////////////////////////////////////
4842 /*char lowerladdersupportname[30];
4843 TGeoXtru* lowerladdersupportshape[fgklayernumber];
4844 TGeoVolume* lowerladdersupport[fgklayernumber];
4845 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4846 lowerladdersupportrot->SetAngles(90.,180.,-90);
4847 for(Int_t i=0; i<fgklayernumber; i++){
4848 lowerladdersupportshape[i] = new TGeoXtru(2);
4849 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
4850 xmothervertex[i],ymothervertex[i]);
4851 lowerladdersupportshape[i]->DefineSection(0,0.);
4852 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4853 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
4854 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
4855 lowerladdersupportshape[i],fSSDSupportRingAl);
4856 lowerladdersupport[i]->SetLineColor(fColorAl);
4857 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
4858 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
4860 /////////////////////////////////////////////////////////////
4861 // Deallocating memory
4862 /////////////////////////////////////////////////////////////
4863 for(Int_t i=0; i<fgklayernumber; i++){
4864 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
4865 delete ringsupportvertex[i][j];
4866 delete [] ringsupportvertex[i];
4868 for(Int_t i=0; i<fgklayernumber; i++){
4869 delete [] xmothervertex[i];
4870 delete [] ymothervertex[i];
4872 delete [] xmothervertex;
4873 delete [] ymothervertex;
4875 for(Int_t i=0; i<fgklayernumber; i++){
4876 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
4877 delete laddersupportrot[i][j];
4878 delete [] laddersupportrot[i];
4881 ////////////////////////////////////////////////////////////////////////////////
4882 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
4883 /////////////////////////////////////////////////////////////
4884 // Method generating Endcap CoverPlate
4885 /////////////////////////////////////////////////////////////
4888 Int_t nendcapcoverplateholedges = 30;
4889 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
4890 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
4891 0.5*fgkEndCapCoverPlateThickness};
4892 TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
4893 nendcapcoverplateholedges,holesection);
4894 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
4895 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
4896 endcapcoverplatesmallhole->SetLineColor(6);
4897 TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
4898 nendcapcoverplateholedges,holesection);
4899 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
4900 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
4901 endcapcoverplatebighole->SetLineColor(6);
4902 //////////////////////////
4903 // Screw Piece Definition
4904 //////////////////////////
4905 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
4906 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
4907 CosD(0.5*smallscrewangle),
4908 0.5*fgkEndCapCoverPlateThickness);
4909 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
4910 endcapsmallscrewpieceshape,
4911 fSSDCoolingTubePhynox);
4912 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
4916 TGeoBBox* endcapcoverplateboxshape[4];
4917 TGeoVolume* endcapcoverplatebox[4];
4918 Double_t boxorigin[5][3];
4919 boxorigin[0][0] = 0.;
4920 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
4921 boxorigin[0][2] = 0.;
4923 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
4924 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
4925 boxorigin[1][2] = 0.;
4927 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
4928 + fgkEndCapCoverPlateSmallHoleSeparation[1];
4929 boxorigin[2][1] = boxorigin[1][1];
4930 boxorigin[2][2] = 0.;
4932 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
4933 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
4934 boxorigin[3][1] = boxorigin[1][1];
4935 boxorigin[3][2] = 0.;
4937 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4938 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
4939 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
4940 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
4942 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4943 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4944 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4945 + fgkEndCapCoverPlateSmallHoleRadius,
4946 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
4948 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4949 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4950 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4951 + fgkEndCapCoverPlateSmallHoleRadius,
4952 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
4954 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
4955 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4956 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4957 + fgkEndCapCoverPlateSmallHoleRadius,
4958 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
4960 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
4961 fSSDAlCoolBlockMedium);
4962 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
4963 fSSDAlCoolBlockMedium);
4964 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
4965 fSSDAlCoolBlockMedium);
4966 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
4967 fSSDAlCoolBlockMedium);
4968 endcapcoverplatebox[0]->SetLineColor(6);
4969 endcapcoverplatebox[1]->SetLineColor(6);
4970 endcapcoverplatebox[2]->SetLineColor(6);
4971 endcapcoverplatebox[3]->SetLineColor(6);
4972 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
4973 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4974 fgkEndCapCoverPlateSmallHoleRadius,
4975 0.5*fgkEndCapCoverPlateThickness,
4976 endcapfillingboxorigin);
4977 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
4978 fSSDAlCoolBlockMedium);
4979 endcapfillingbox->SetLineColor(6);
4980 ////////////////////////////
4981 // Contour shape Definition
4982 ////////////////////////////
4983 const Int_t kcontourvertexnumber = 10;
4984 Double_t xcontourvertex[kcontourvertexnumber];
4985 Double_t ycontourvertex[kcontourvertexnumber];
4986 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
4987 xcontourvertex[1] = xcontourvertex[0];
4988 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4989 xcontourvertex[3] = xcontourvertex[2];
4990 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
4991 xcontourvertex[5] = xcontourvertex[4];
4992 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4993 xcontourvertex[7] = xcontourvertex[6];
4994 xcontourvertex[8] = xcontourvertex[4];
4995 xcontourvertex[9] = xcontourvertex[8];
4996 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4997 - (kendcapcoverplatesmallholenumber[1]-1)
4998 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4999 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5000 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5001 ycontourvertex[2] = ycontourvertex[1];
5002 ycontourvertex[3] = ycontourvertex[0];
5003 ycontourvertex[4] = ycontourvertex[3];
5004 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5005 ycontourvertex[6] = ycontourvertex[5];
5006 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5007 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5008 + fgkEndCapCoverPlateSmallHoleRadius;
5009 ycontourvertex[8] = ycontourvertex[7];
5010 ycontourvertex[9] = ycontourvertex[0];
5012 Double_t xboxin, dxboxin, yboxin, dyboxin;
5013 Double_t xboxout, dxboxout, yboxout, dyboxout;
5014 Double_t coordmin, coordmax;
5015 coordmin = -fgkEndCapCoverPlateLength[0];
5016 coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5017 xboxout = 0.5*(coordmin+coordmax);
5018 dxboxout = 0.5*(coordmax-coordmin);
5019 coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5020 - (kendcapcoverplatesmallholenumber[1]-1)
5021 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5022 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5023 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5024 yboxout = 0.5*(coordmin+coordmax);
5025 dyboxout = 0.5*(coordmax-coordmin);
5026 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5027 coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5028 xboxin = 0.5*(coordmin+coordmax);
5029 dxboxin = 0.5*(coordmax-coordmin);
5030 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5031 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5032 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5033 + fgkEndCapCoverPlateSmallHoleRadius;
5034 yboxin = 0.5*(coordmin+coordmax);
5035 dyboxin = 0.5*(coordmax-coordmin);
5036 new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5037 TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5038 xboxout, yboxout, 0.);
5039 trendCapCoverPlateContourboxout->RegisterYourself();
5040 new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5041 TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5042 xboxin, yboxin, 0.);
5043 trendCapCoverPlateContourboxin->RegisterYourself();
5044 TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5045 "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5047 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5048 fSSDAlCoolBlockMedium);
5049 contour->SetLineColor(6);
5050 /////////////////////////////
5051 // Hole Contour Shape Definition
5052 ////////////////////////////
5053 coordmin = xcontourvertex[0];
5054 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5055 xboxout = 0.5*(coordmin+coordmax);
5056 dxboxout = 0.5*(coordmax-coordmin);
5057 coordmin = ycontourvertex[1];
5058 coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5059 yboxout = 0.5*(coordmin+coordmax);
5060 dyboxout = 0.5*(coordmax-coordmin);
5061 coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5062 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5063 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5064 xboxin = 0.5*(coordmin+coordmax);
5065 dxboxin = 0.5*(coordmax-coordmin);
5066 coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5067 - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5068 coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5069 yboxin = 0.5*(coordmin+coordmax);
5070 dyboxin = 0.5*(coordmax-coordmin);
5071 new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5072 TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5073 xboxout, yboxout, 0.);
5074 trendCapCoverPlateContourboxout1->RegisterYourself();
5075 new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5076 TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5077 xboxin, yboxin, 0.);
5078 trendCapCoverPlateContourboxin1->RegisterYourself();
5079 TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5080 "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5083 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5084 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5085 xboxout = 0.5*(coordmin+coordmax);
5086 dxboxout = 0.5*(coordmax-coordmin);
5087 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5088 - fgkEndCapCoverPlateWidth[0]);
5089 coordmax = ycontourvertex[0];
5090 yboxout = 0.5*(coordmin+coordmax);
5091 dyboxout = 0.5*(coordmax-coordmin);
5092 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5093 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5094 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5095 xboxin = 0.5*(coordmin+coordmax);
5096 dxboxin = 0.5*(coordmax-coordmin);
5097 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5098 - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5099 - fgkEndCapCoverPlateWidth[0]
5100 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5101 coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5102 yboxin = 0.5*(coordmin+coordmax);
5103 dyboxin = 0.5*(coordmax-coordmin);
5104 new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5105 TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5106 xboxout, yboxout, 0.);
5107 trendCapCoverPlateContourboxout2->RegisterYourself();
5108 new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5109 TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5110 xboxin, yboxin, 0.);
5111 trendCapCoverPlateContourboxin2->RegisterYourself();
5112 TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5113 "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5115 // const Int_t kholecontourvertexnumber = 10;
5117 Double_t xholecontourvertex[2][kcontourvertexnumber];
5118 Double_t yholecontourvertex[2][kcontourvertexnumber];
5119 xholecontourvertex[0][0] = xcontourvertex[0];
5120 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5121 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5122 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5123 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5124 + 0.5*(fgkEndCapCoverPlateLength[2]
5125 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5126 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5127 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5128 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5129 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5130 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5131 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5133 yholecontourvertex[0][0] = ycontourvertex[1];
5134 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5135 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5136 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5137 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5138 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5139 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5140 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5141 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5142 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5143 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5145 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5146 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5147 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5148 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5149 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5150 + 0.5*(fgkEndCapCoverPlateLength[2]
5151 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5152 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5153 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5154 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5155 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5156 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5157 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5159 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5160 - fgkEndCapCoverPlateWidth[0]);
5161 yholecontourvertex[1][1] = ycontourvertex[0];
5162 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5163 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5164 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5165 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5166 - fgkEndCapCoverPlateWidth[0]
5167 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5168 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5169 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5170 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5171 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5173 TGeoVolume* holecontour[2];
5174 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
5175 fSSDAlCoolBlockMedium);
5176 holecontour[0]->SetLineColor(6);
5177 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
5178 fSSDAlCoolBlockMedium);
5179 holecontour[1]->SetLineColor(6);
5180 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5181 + fgkEndCapCoverPlateLength[2],0.,0.);
5182 TGeoTranslation* bigholetrans[3];
5183 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5184 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5185 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5186 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5187 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5188 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5189 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5190 /////////////////////////////////
5191 // Mother Volume Xtru Definition
5192 /////////////////////////////////
5193 const Int_t kmothervertexnumber = 12;
5194 Double_t xmothervertex[kmothervertexnumber];
5195 Double_t ymothervertex[kmothervertexnumber];
5196 xmothervertex[0] = xcontourvertex[0];
5197 xmothervertex[1] = xmothervertex[0];
5198 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5199 xmothervertex[3] = xmothervertex[2];
5200 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5201 xmothervertex[5] = xmothervertex[4];
5202 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5203 xmothervertex[7] = xmothervertex[6];
5204 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5205 + fgkEndCapCoverPlateLength[2];
5206 xmothervertex[9] = xmothervertex[8];
5207 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5208 xmothervertex[11] = xmothervertex[10];
5210 ymothervertex[0] = ycontourvertex[0];
5211 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5212 ymothervertex[2] = ymothervertex[1];
5213 ymothervertex[3] = ycontourvertex[1];
5214 ymothervertex[4] = ymothervertex[3];
5215 ymothervertex[5] = ymothervertex[1];
5216 ymothervertex[6] = ymothervertex[5];
5217 ymothervertex[7] = ymothervertex[0];
5218 ymothervertex[8] = ymothervertex[7];
5219 ymothervertex[9] = ymothervertex[8]
5220 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5221 ymothervertex[10] = ymothervertex[9];
5222 ymothervertex[11] = ymothervertex[8];
5223 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5224 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5225 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5226 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5227 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5228 ////////////////////////////////////////
5230 ////////////////////////////////////////
5231 // TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5232 TGeoTranslation*** endcapcoverplatesmallholetrans;
5233 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5234 Double_t transx[4] = {0,
5235 fgkEndCapCoverPlateSmallHoleSeparation[0],
5236 fgkEndCapCoverPlateSmallHoleSeparation[0]
5237 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5238 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5239 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5241 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5242 endcapcoverplatesmallholetrans[i] =
5243 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5244 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5245 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5246 endcapcoverplatesmallholetrans[i][j] =
5247 new TGeoTranslation(transx[i],
5248 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5250 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5251 index,endcapcoverplatesmallholetrans[i][j]);
5252 mothercoverplate->AddNode(endcapsmallscrewpiece,
5253 index,endcapcoverplatesmallholetrans[i][j]);
5255 if(j<kendcapcoverplatesmallholenumber[1]-1)
5256 mothercoverplate->AddNode(endcapcoverplatebox[0],
5257 index,endcapcoverplatesmallholetrans[i][j]);
5260 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5261 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5262 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5263 mothercoverplate->AddNode(endcapfillingbox,1);
5264 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5265 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5266 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5267 mothercoverplate->AddNode(holecontour[0],1);
5268 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5269 mothercoverplate->AddNode(holecontour[1],1);
5270 mothercoverplate->AddNode(contour,1);
5271 /////////////////////////////////
5272 return mothercoverplate;
5274 ////////////////////////////////////////////////////////////////////////////////
5275 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5276 /////////////////////////////////////////////////////////////
5277 // Getting EndCap Cooling Tube
5278 /////////////////////////////////////////////////////////////
5279 TGeoTorus* endcapcoolingtubetorushape[5];
5280 TGeoVolume* endcapcoolingtubetorus[5];
5281 TGeoTube* endcapcoolingtubeshape[4];
5282 TGeoVolume* endcapcoolingtube[4];
5283 char endcapcoolingtubetorusname[100];
5284 char endcapcoolingtubename[100];
5285 TGeoTorus* endcapcoolingwatertubetorushape[5];
5286 TGeoVolume* endcapcoolingwatertubetorus[5];
5287 TGeoTube* endcapcoolingwatertubeshape[4];
5288 TGeoVolume* endcapcoolingwatertube[4];
5289 char endcapcoolingwatertubetorusname[100];
5290 char endcapcoolingwatertubename[100];
5291 for(Int_t i=0; i<5; i++){
5292 sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5293 sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5294 sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5295 sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5297 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5298 fgkEndCapCoolingTubeRadiusMin,
5299 fgkEndCapCoolingTubeRadiusMax,
5300 90.0,fgkEndCapCoolingTubeAngle[3]);
5301 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5302 0.,fgkEndCapCoolingTubeRadiusMin,
5303 90.0,fgkEndCapCoolingTubeAngle[3]);
5306 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5307 :fgkEndCapCoolingTubeAxialRadius[1],
5308 fgkEndCapCoolingTubeRadiusMin,
5309 fgkEndCapCoolingTubeRadiusMax,
5310 0.,fgkEndCapCoolingTubeAngle[i]);
5311 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5312 :fgkEndCapCoolingTubeAxialRadius[1],
5313 0.,fgkEndCapCoolingTubeRadiusMin,
5314 0.,fgkEndCapCoolingTubeAngle[i]);
5316 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5317 endcapcoolingtubetorushape[i],
5318 fSSDCoolingTubePhynox);
5319 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5320 endcapcoolingwatertubetorushape[i],
5321 fSSDCoolingTubeWater);
5322 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5323 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5325 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5326 fgkEndCapCoolingTubeRadiusMax,
5327 0.5*fgkEndCapCoolingTubeLength[i]);
5328 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5329 0.5*fgkEndCapCoolingTubeLength[i]);
5330 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5331 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5332 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5333 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5334 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5335 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5338 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5339 /////////////////////////////////////////
5340 // Transformation for Volume Positioning
5341 /////////////////////////////////////////
5342 TGeoCombiTrans* coolingtubecombitrans[6];
5343 TGeoRotation* coolingtuberot[8];
5344 TGeoTranslation* coolingtubetrans[6];
5345 TGeoHMatrix* coolingtubematrix[4];
5346 TGeoCombiTrans* torustubecombitrans[4];
5347 TGeoRotation* torustuberot[7];
5348 TGeoTranslation* torustubetrans[4];
5349 TGeoHMatrix* torustubematrix[5];
5350 TGeoCombiTrans* coolingwatertubecombitrans[6];
5351 TGeoRotation* coolingwatertuberot[8];
5352 TGeoTranslation* coolingwatertubetrans[6];
5353 TGeoHMatrix* coolingwatertubematrix[4];
5354 TGeoCombiTrans* toruswatertubecombitrans[4];
5355 TGeoRotation* toruswatertuberot[7];
5356 TGeoTranslation* toruswatertubetrans[4];
5357 TGeoHMatrix* toruswatertubematrix[5];
5358 for(Int_t i=0; i<8; i++){
5360 coolingtubetrans[i] = new TGeoTranslation();
5361 coolingwatertubetrans[i] = new TGeoTranslation();
5364 coolingtuberot[i] = new TGeoRotation();
5365 coolingwatertuberot[i] = new TGeoRotation();
5368 torustubetrans[i] = new TGeoTranslation();
5369 toruswatertubetrans[i] = new TGeoTranslation();
5372 torustuberot[i] = new TGeoRotation();
5373 toruswatertuberot[i] = new TGeoRotation();
5376 /////////////////////////////////////////
5377 // Transformation for Inox Volume Positioning
5378 /////////////////////////////////////////
5379 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5380 -endcapcoolingtubeshape[0]->GetDz(),0.);
5381 coolingtuberot[0]->SetAngles(0.,90.,0.);
5382 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5383 *coolingtuberot[0]);
5385 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5386 coolingtuberot[1]->SetAngles(0.,90.,0.);
5387 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5388 *coolingtuberot[1]);
5390 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5391 *CosD(fgkEndCapCoolingTubeAngle[0]),
5392 fgkEndCapCoolingTubeAxialRadius[0]
5393 *SinD(fgkEndCapCoolingTubeAngle[0]),
5395 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5396 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5397 *coolingtuberot[2]);
5399 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5400 * (*coolingtubecombitrans[1]));
5402 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5403 endcapcoolingtubeshape[1]->GetDz());
5404 torustuberot[0]->SetAngles(0.,90.,0.);
5405 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5407 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5409 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5410 -endcapcoolingtubeshape[2]->GetDz(),0.);
5411 coolingtuberot[3]->SetAngles(0.,90.,0.);
5412 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5413 *coolingtuberot[3]);
5414 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5415 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5416 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5418 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5419 endcapcoolingtubeshape[2]->GetDz());
5420 torustuberot[1]->SetAngles(0.,90.,0.);
5421 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5422 torustuberot[2]->SetAngles(180.,0.,0.);
5423 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5424 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5426 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5427 -fgkEndCapCoolingTubeAxialRadius[0]);
5428 torustuberot[3]->SetAngles(0.,90.,0.);
5429 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5430 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5431 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5432 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5434 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5435 fgkEndCapCoolingTubeAxialRadius[0],0.);
5436 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5437 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5438 *coolingtuberot[5]);
5439 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5440 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5441 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5443 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5444 endcapcoolingtubeshape[0]->GetDz());
5445 torustuberot[5]->SetAngles(0.,90.,0.);
5446 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5447 torustuberot[6]->SetAngles(-90.,0.,0.);
5448 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5449 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5451 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5452 endcapcoolingtubeshape[3]->GetDz(),0.);
5453 coolingtuberot[6]->SetAngles(0.,90.,0.);
5454 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5455 *coolingtuberot[6]);
5456 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5457 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5458 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5459 /////////////////////////////////////////
5460 // Transformation for Water Volume Positioning
5461 /////////////////////////////////////////
5462 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5463 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5464 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5465 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5466 *coolingwatertuberot[0]);
5468 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5469 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5470 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5471 *coolingwatertuberot[1]);
5473 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5474 *CosD(fgkEndCapCoolingTubeAngle[0]),
5475 fgkEndCapCoolingTubeAxialRadius[0]
5476 *SinD(fgkEndCapCoolingTubeAngle[0]),
5478 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5479 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5480 *coolingwatertuberot[2]);
5482 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5483 * (*coolingwatertubecombitrans[1]));
5485 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5486 endcapcoolingwatertubeshape[1]->GetDz());
5487 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5488 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5489 *toruswatertuberot[0]);
5491 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5492 * (*toruswatertubecombitrans[0]));
5494 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5495 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5496 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5497 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5498 *coolingwatertuberot[3]);
5499 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5500 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5501 * (*coolingwatertubecombitrans[3]));
5502 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5504 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5505 endcapcoolingwatertubeshape[2]->GetDz());
5506 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5507 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5508 *toruswatertuberot[1]);
5509 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5510 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5511 * (*toruswatertubecombitrans[1]));
5512 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5514 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5515 -fgkEndCapCoolingTubeAxialRadius[0]);
5516 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5517 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5518 *toruswatertuberot[3]);
5519 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5520 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5521 * (*toruswatertubecombitrans[2]));
5522 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5524 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5525 fgkEndCapCoolingTubeAxialRadius[0],0.);
5526 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5527 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5528 *coolingwatertuberot[5]);
5529 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5530 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5531 * (*coolingwatertubecombitrans[4]));
5532 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5534 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5535 endcapcoolingwatertubeshape[0]->GetDz());
5536 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5537 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5538 *toruswatertuberot[5]);
5539 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5540 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5541 * (*toruswatertubecombitrans[3]));
5542 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5544 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5545 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5546 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5547 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5548 *coolingwatertuberot[6]);
5549 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5550 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5551 * (*coolingwatertubecombitrans[5]));
5552 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5553 /////////////////////////////////////////
5554 // Positioning Volumes
5555 /////////////////////////////////////////
5556 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5557 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5559 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5560 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5562 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5563 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5565 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5566 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5568 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5569 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5571 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5572 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5574 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5575 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5577 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5578 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5580 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5581 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5583 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5584 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5585 /////////////////////////////////////////////////////////////
5586 // Deallocating memory
5587 /////////////////////////////////////////////////////////////
5588 for(Int_t i=0; i<8; i++){
5590 delete coolingtubetrans[i];
5591 delete coolingwatertubetrans[i];
5593 delete coolingtubecombitrans[i];
5594 delete coolingwatertubecombitrans[i];
5598 delete coolingtuberot[i];
5599 delete coolingwatertuberot[i];
5602 delete torustubetrans[i];
5603 delete toruswatertubetrans[i];
5604 delete torustubecombitrans[i];
5605 delete toruswatertubecombitrans[i];
5608 delete torustuberot[i];
5609 delete toruswatertuberot[i];
5612 /////////////////////////////////////////////////////////////
5613 return endcapcoolingtubemother;
5615 ////////////////////////////////////////////////////////////////////////////////
5616 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5617 /////////////////////////////////////////////////////////////
5618 // Getting EndCap Cover Side
5619 /////////////////////////////////////////////////////////////
5620 const Int_t kendcapcoverholenumber[2] = {7,5};
5621 const Int_t kvertexnumber = 15;
5622 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5624 xvertex[1] = xvertex[0];
5625 xvertex[2] = fgkEndCapSideCoverLength[0];
5626 xvertex[3] = fgkEndCapSideCoverLength[1];
5627 xvertex[4] = xvertex[3];
5628 xvertex[5] = fgkEndCapSideCoverLength[2];
5629 xvertex[6] = xvertex[5];
5630 xvertex[7] = xvertex[2];
5631 xvertex[8] = xvertex[7];
5632 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5633 xvertex[10] = xvertex[9];
5634 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5635 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5636 * fgkEndCapSideCoverLength[4];
5637 xvertex[12] = xvertex[11];
5638 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5639 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5640 * fgkEndCapSideCoverLength[4];
5641 xvertex[14] = xvertex[13];
5643 yvertex[1] = fgkEndCapSideCoverWidth[0];
5644 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5645 yvertex[3] = yvertex[2];
5646 yvertex[4] = fgkEndCapSideCoverWidth[1];
5647 yvertex[5] = yvertex[4];
5648 yvertex[6] = yvertex[0];
5649 yvertex[7] = yvertex[6];
5650 yvertex[8] = fgkEndCapSideCoverWidth[6];
5651 yvertex[9] = yvertex[8];
5652 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5653 yvertex[11] = yvertex[10];
5654 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5655 yvertex[13] = yvertex[12];
5656 yvertex[14] = yvertex[6];
5657 TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5658 endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5659 endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5660 endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5661 endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5662 TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5663 endcapsidecovershapein->SetName("endcapsidecovershapein");
5664 endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5665 endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5666 endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5669 TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
5670 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5671 endcapsidecovershape,fSSDCoolingTubePhynox);
5672 endcapsidecover->SetLineColor(fColorPhynox);
5673 ////////////////////////////////////////////
5674 // Defininition of Mother Volume
5675 ////////////////////////////////////////////
5676 const Int_t kmothervertexnumber = 7;
5677 Double_t xmothervertex[kmothervertexnumber];
5678 Double_t ymothervertex[kmothervertexnumber];
5679 for(Int_t i=0; i<kmothervertexnumber; i++){
5680 xmothervertex[i] = xvertex[i];
5681 ymothervertex[i] = yvertex[i];
5683 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5684 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5685 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5686 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5687 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5688 endcapsidecovermothershape,fSSDAir);
5689 ////////////////////////////////////////////
5690 endcapsidecovermother->AddNode(endcapsidecover,1);
5691 TGeoBBox* endcapsidecoverboxshape[4];
5692 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5693 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5694 0.5*fgkEndCapSideCoverLength[4],
5695 0.5*fgkEndCapSideCoverThickness);
5696 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5697 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5698 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5699 - fgkEndCapSideCoverLength[4]),
5700 0.5*fgkEndCapSideCoverThickness);
5701 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5702 0.5*fgkEndCapSideCoverLength[4],
5703 0.5*fgkEndCapSideCoverThickness);
5704 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5705 0.5*fgkEndCapSideCoverWidth[5],
5706 0.5*fgkEndCapSideCoverThickness);
5707 TGeoVolume* endcapsidecoverbox[4];
5708 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5709 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5710 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5711 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5712 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5713 // TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5714 TGeoTranslation** endcapsidecoverboxtrans;
5715 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5716 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5717 + fgkEndCapSideCoverLength[0],
5718 endcapsidecoverboxshape[0]->GetDY()
5719 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5720 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5722 endcapsidecoverboxshape[1]->GetDY()
5724 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5726 endcapsidecoverboxshape[2]->GetDY()
5728 + 2.*endcapsidecoverboxshape[1]->GetDY()
5729 + fgkEndCapSideCoverWidth[5],0.);
5730 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5731 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5732 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5733 for(Int_t i=0; i<2; i++)
5734 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5735 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5736 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5737 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5738 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5739 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5740 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5741 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5743 for(Int_t i=0; i<2; i++)
5744 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5745 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5746 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5747 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5748 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5749 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5750 +fgkEndCapSideCoverLength[4]),0.0);
5751 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5752 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5753 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5754 +i*(kendcapcoverholenumber[1]-1)+j]);
5756 return endcapsidecovermother;
5758 ////////////////////////////////////////////////////////////////////////////////
5759 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5760 ////////////////////////////////////////////////////////////////////////////////
5761 // Method returning Interface Card A, Interface Card B, Supply Card
5762 ////////////////////////////////////////////////////////////////////////////////
5763 /////////////////////
5765 /////////////////////
5766 // Electronic Board Back Al Plane
5767 const Int_t kelectboardbackvertexnumber = 8;
5768 Double_t xelectboardback[kelectboardbackvertexnumber];
5769 Double_t yelectboardback[kelectboardbackvertexnumber];
5770 xelectboardback[0] = 0.0;
5771 xelectboardback[1] = xelectboardback[0];
5772 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5773 xelectboardback[3] = xelectboardback[2];
5774 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5775 xelectboardback[5] = xelectboardback[4];
5776 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5777 xelectboardback[7] = xelectboardback[6];
5779 yelectboardback[0] = 0.0;
5780 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5781 yelectboardback[2] = yelectboardback[1];
5782 yelectboardback[3] = yelectboardback[0];
5783 yelectboardback[4] = yelectboardback[3];
5784 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5785 yelectboardback[6] = yelectboardback[5];
5786 yelectboardback[7] = yelectboardback[4];
5787 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5788 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5789 xelectboardback,yelectboardback);
5790 electboardbackshape->DefineSection(0,0.0);
5791 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5792 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5793 electboardbackshape,fSSDSupportRingAl);
5794 electboardback->SetLineColor(fColorAl);
5795 // Electronic Board Kapton Layer
5796 const Int_t kelectlayervertexnumber = 8;
5797 Double_t xelectlayer[kelectlayervertexnumber];
5798 Double_t yelectlayer[kelectlayervertexnumber];
5799 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5800 xelectlayer[1] = xelectlayer[0];
5801 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5802 xelectlayer[3] = xelectlayer[2];
5803 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5805 yelectlayer[0] = 0.0;
5806 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5807 yelectlayer[2] = yelectlayer[1];
5808 yelectlayer[3] = yelectlayer[0];
5809 yelectlayer[4] = yelectlayer[3];
5810 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5811 yelectlayer[6] = yelectlayer[5];
5812 yelectlayer[7] = yelectlayer[4];
5813 TGeoXtru* electlayershape = new TGeoXtru(2);
5814 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5815 electlayershape->DefineSection(0,0.0);
5816 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5817 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5818 electlayershape,fSSDKaptonFlexMedium);
5819 electlayer->SetLineColor(fColorKapton);
5820 // JMD Connector Female
5821 const Int_t kjmdconnectorvertexnumber = 6;
5822 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5823 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5824 xjmdconnectorvertex[0] = 0.0;
5825 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5826 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5827 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5828 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5829 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5831 yjmdconnectorvertex[0] = 0.0;
5832 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5833 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5834 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5835 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5836 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5837 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5838 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5839 yjmdconnectorvertex);
5840 jmdconnectorshape->DefineSection(0,0.0);
5841 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5842 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5843 jmdconnectorshape,fSSDMountingBlockMedium);
5844 jmdconnector->SetLineColor(fColorG10);
5845 // Top Cable Connector
5846 const Int_t kcableconnectorvertexnumber = 8;
5847 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5848 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5849 xconnectorvertex[0] = 0.0;
5850 xconnectorvertex[1] = xconnectorvertex[0];
5851 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5852 xconnectorvertex[3] = xconnectorvertex[2];
5853 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5854 - fgkEndCapCardCableConnectorLength[2];
5855 xconnectorvertex[5] = xconnectorvertex[4];
5856 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5857 xconnectorvertex[7] = xconnectorvertex[6];
5859 yconnectorvertex[0] = 0.0;
5860 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5861 yconnectorvertex[2] = yconnectorvertex[1];
5862 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5863 yconnectorvertex[4] = yconnectorvertex[3];
5864 yconnectorvertex[5] = yconnectorvertex[1];
5865 yconnectorvertex[6] = yconnectorvertex[5];
5866 yconnectorvertex[7] = yconnectorvertex[0];
5867 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5868 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5870 cableconnectorshape->DefineSection(0,0.0);
5871 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5872 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5873 cableconnectorshape,fSSDMountingBlockMedium);
5874 cableconnector->SetLineColor(fColorG10);
5876 TGeoBBox* endcapstripconnectionshape =
5877 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5878 0.5*fgkEndCapStripConnectionThickness,
5879 0.5*fgkEndCapStripConnectionWidth);
5880 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5881 endcapstripconnectionshape,
5883 endcapstripconnection->SetLineColor(fColorAl);
5885 const Int_t kcardBvertexnumber = 12;
5886 Double_t xcardBvertexnumber[kcardBvertexnumber];
5887 Double_t ycardBvertexnumber[kcardBvertexnumber];
5889 xcardBvertexnumber[0] = 0.0;
5890 xcardBvertexnumber[1] = xcardBvertexnumber[0];
5891 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5892 xcardBvertexnumber[3] = xcardBvertexnumber[2];
5893 xcardBvertexnumber[4] = xcardBvertexnumber[1];
5894 xcardBvertexnumber[5] = xcardBvertexnumber[4];
5895 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5896 xcardBvertexnumber[7] = xcardBvertexnumber[6];
5897 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5898 xcardBvertexnumber[9] = xcardBvertexnumber[8];
5899 xcardBvertexnumber[10] = xcardBvertexnumber[7];
5900 xcardBvertexnumber[11] = xcardBvertexnumber[10];
5902 ycardBvertexnumber[0] = 0.0;
5903 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
5904 ycardBvertexnumber[2] = ycardBvertexnumber[1];
5905 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5906 ycardBvertexnumber[4] = ycardBvertexnumber[3];
5907 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5908 ycardBvertexnumber[6] = ycardBvertexnumber[5];
5909 ycardBvertexnumber[7] = ycardBvertexnumber[4];
5910 ycardBvertexnumber[8] = ycardBvertexnumber[7];
5911 ycardBvertexnumber[9] = ycardBvertexnumber[1];
5912 ycardBvertexnumber[10] = ycardBvertexnumber[9];
5913 ycardBvertexnumber[11] = ycardBvertexnumber[0];
5915 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5916 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5917 interfacecardBshape->DefineSection(0,0.);
5918 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5919 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5920 fSSDMountingBlockMedium);
5921 interfacecardB->SetLineColor(46);
5922 // Interface Card B Electronic Board
5923 const Int_t kelectboardcardBvertexnumber = 14;
5924 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5925 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5927 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5928 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
5929 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
5930 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
5931 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
5932 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
5933 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
5934 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
5935 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
5936 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
5937 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
5938 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
5939 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
5940 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
5942 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
5943 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
5944 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
5945 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
5946 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
5947 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
5948 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
5949 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
5950 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
5951 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
5952 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
5953 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
5954 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
5955 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
5957 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
5958 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
5959 xelectboardcardBvertex,yelectboardcardBvertex);
5960 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
5961 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
5962 + fgkEndCapInterfaceElectBoardCardBThickness);
5963 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
5965 electboardcardB->SetLineColor(fColorAl);
5966 // Generating Stiffener 2
5967 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
5968 0.5*fgkEndCapStiffenerThickness,
5969 0.5*fgkEndCapStiffenerLength);
5970 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
5971 endcapstiffener->SetLineColor(fColorAl);
5972 // Generating Mother Interface Card B Container
5973 const Int_t kinterfacecardBmothervertexnumber = 10;
5974 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5975 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5977 xinterfacecardBmothervertex[0] = 0.0;
5978 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
5979 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
5980 + fgkEndCapInterfaceCardBThickness;
5981 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
5982 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
5983 + fgkEndCapInterfaceElectBoardCardBThickness;
5984 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
5985 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
5986 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
5987 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
5988 + fgkEndCapCardJMDConnectorLength[0];
5989 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
5991 yinterfacecardBmothervertex[0] = 0.0;
5992 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
5993 + fgkEndCapInterfaceCardBWidth[1]
5994 + fgkEndCapInterfaceCardBWidth[2];
5995 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
5996 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
5997 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
5998 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
5999 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6000 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6001 + fgkEndCapCardJMDConnectorWidth[0]
6002 + fgkEndCapCardJMDConnectorWidth[1];
6003 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6004 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6005 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6006 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6007 xinterfacecardBmothervertex,
6008 yinterfacecardBmothervertex);
6009 interfacecardBmothershape->DefineSection(0,-1.e-15);
6010 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6011 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6012 interfacecardBmothershape,fSSDAir);
6013 electboardcardB->SetLineColor(fColorAl);
6014 // Positioning Volumes Mother Interface Card B Container
6015 TGeoRotation* interfacecardBrot = new TGeoRotation();
6016 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6017 interfacecardBrot->SetAngles(90.,-90.,-90.);
6018 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6019 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6020 TGeoRotation* electboardcardBrot = new TGeoRotation();
6021 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6022 electboardcardBrot->SetAngles(90.,90.,-90.);
6023 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6024 TGeoCombiTrans* electboardcardBcombitrans =
6025 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6026 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6027 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6028 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6029 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6030 TGeoTranslation* jmdconnectorcardBtrans[3];
6031 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6032 for(Int_t i=0; i<3; i++){
6033 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6034 + fgkEndCapCardJMDConnectorLength[0],
6035 fgkEndCapCardElectBoardLayerWidth[1],
6036 0.5*fgkEndCapCardJMDConnectorThickness
6037 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6038 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6039 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6040 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6041 *jmdconnectorcardBrot);
6042 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6044 // Mother Supply Card Container
6045 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6046 // Interface Card Container
6047 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6048 // Placing Volumes in Mother Supply Card Container
6049 // JMD Connector Positioning
6050 TGeoTranslation* jmdconnectortrans[2];
6051 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6052 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6053 fgkEndCapCardElectBoardBackLength[0]
6054 - fgkEndCapCardJMDConnectorThickness
6055 - fgkEndCapCardJMDConnectorToLayer);
6056 TGeoRotation* jmdconnectorot = new TGeoRotation();
6057 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6058 + 2.*fgkEndCapCardJMDConnectorLength[0]
6059 + 2.*fgkEndCapCardElectBoardLayerThickness,
6060 fgkEndCapCardElectBoardLayerWidth[1],
6061 fgkEndCapCardJMDConnectorThickness
6062 + fgkEndCapCardJMDConnectorToLayer);
6063 jmdconnectorot->SetAngles(90.,180.,-90);
6064 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6066 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6067 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6068 // Top Cable Connector Placing
6069 TGeoRotation* cableconnectorot[2];
6070 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6071 TGeoTranslation* cableconnectortrans[3];
6072 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6073 cableconnectorot[0]->SetAngles(90.,0.,0.);
6074 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6075 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6076 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6077 *cableconnectorot[0]);
6078 TGeoHMatrix* cableconnectormatrix[2];
6079 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6080 new TGeoHMatrix((*cableconnectorot[1])
6081 *(*cableconnectorcombitrans));
6082 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6083 - fgkEndCapCardCableConnectorThickness,
6084 fgkEndCapCardCableConnectorLength[0]
6085 + fgkEndCapCardCableConnectorToLayer);
6086 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6087 - 2.*fgkEndCapCardCableConnectorThickness
6088 - fgkEndCapCardCableConnectorDistance,
6089 fgkEndCapCardCableConnectorLength[0]
6090 + fgkEndCapCardCableConnectorToLayer);
6091 for(Int_t i=0; i<2; i++){
6092 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6093 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6095 TGeoRotation* electboardbackrot = new TGeoRotation();
6096 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6097 electboardbackrot->SetAngles(90.,-90.,-90.);
6098 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6099 + fgkEndCapCardJMDConnectorLength[0]
6100 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6101 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6102 *electboardbackrot);
6103 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6104 // Electronic Board Kapton Layer Positioning
6105 TGeoRotation* electlayerrot = new TGeoRotation();
6106 TGeoTranslation* electlayertrans[2];
6107 TGeoCombiTrans* electlayercombitrans[2];
6108 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6109 electlayerrot->SetAngles(90.,-90.,-90.);
6110 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6111 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6112 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6113 + 2.*fgkEndCapCardElectBoardLayerThickness
6114 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6115 for(Int_t i=0; i<2; i++){
6116 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6117 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6119 // Placing Volumes in Mother Interface Card Container
6120 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6121 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6122 for(Int_t i=0; i<2; i++){
6123 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6125 /////////////////////////////////////////////////////////////
6126 // Generation of Card Interface Container
6127 /////////////////////////////////////////////////////////////
6128 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6129 - fgkEndCapCardJMDConnectorLength[0]
6130 - fgkEndCapInterfaceCardBThickness
6131 - 9.*fgkEndCapStripConnectionThickness
6132 - 8.*fgkEndCapCardElectBoardBackThickness;
6133 const Int_t kcardinterfacecontainervertexnumber = 14;
6134 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6135 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6136 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6137 - 7.0*fgkEndCapStripConnectionThickness;
6138 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6139 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6140 + fgkEndCapStripConnectionThickness
6141 - fgkEndCapCardElectBoardLayerThickness
6142 - fgkEndCapCardCableConnectorWidth[0];
6143 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6144 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6145 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6146 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6147 + 2.0*fgkEndCapStripConnectionThickness;
6148 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6149 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6150 + fgkEndCapInterfaceCardBThickness;
6151 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6152 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6153 + fgkEndCapInterfaceElectBoardCardBThickness;
6154 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6155 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6156 - fgkEndCapInterfaceElectBoardCardBThickness
6157 + fgkEndCapCardJMDConnectorLength[0]
6158 + stiffenertransx+fgkEndCapStiffenerWidth;
6159 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6161 ycardinterfacecontainervertex[0] = 0.;
6162 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6163 + fgkEndCapCardJMDConnectorWidth[0]
6164 + fgkEndCapCardJMDConnectorWidth[1];
6165 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6166 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6167 - fgkEndCapStripConnectionWidth;
6168 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6169 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6170 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6171 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6172 + fgkEndCapInterfaceCardBWidth[1]
6173 + fgkEndCapInterfaceCardBWidth[2];
6174 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6175 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6176 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6177 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6178 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6179 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6181 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6182 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6183 xcardinterfacecontainervertex,
6184 ycardinterfacecontainervertex);
6185 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6186 - fgkEndCapCardElectBoardBackLength[0]));
6187 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6188 + fgkEndCapCardElectBoardBackLength[0]));
6189 TGeoVolume** cardinterfacecontainer;
6190 cardinterfacecontainer = new TGeoVolume*[4];
6191 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6192 interfacecardmothershape,fSSDAir);
6193 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6194 interfacecardmothershape,fSSDAir);
6195 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6196 interfacecardmothershape,fSSDAir);
6197 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6198 interfacecardmothershape,fSSDAir);
6199 /////////////////////////////////
6200 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6201 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6202 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6203 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6204 /////////////////////////////////
6205 TGeoRotation* endcapstripconnectionrot[2];
6206 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6207 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6208 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6209 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6210 * (*endcapstripconnectionrot[0]));
6211 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6212 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6213 -0.5*fgkEndCapCardElectBoardBackThickness,
6214 fgkEndCapCardElectBoardBackWidth[0]
6215 -endcapstripconnectionshape->GetDZ(),
6216 0.5*fgkEndCapCardElectBoardBackLength[0]);
6217 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6218 TGeoTranslation* cardinterfacetrans[9];
6219 TGeoHMatrix* cardinterfacematrix[9];
6220 for(Int_t i=0; i<7; i++){
6221 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6222 + fgkEndCapCardElectBoardBackThickness),
6224 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6225 * (*endcapstripconnectionmatrix));
6227 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6228 + fgkEndCapCardElectBoardBackThickness),
6230 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6231 * (*endcapstripconnectionmatrix));
6232 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6233 + fgkEndCapCardElectBoardBackThickness),
6235 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6236 * (*endcapstripconnectionmatrix));
6238 for(Int_t i=0; i<4; i++){
6239 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6240 cardinterfacematrix[7]);
6241 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6242 cardinterfacematrix[8]);
6244 TGeoTranslation* mothersupplycardtrans =
6245 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6246 + 2.*fgkEndCapCardJMDConnectorLength[0]
6247 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6248 TGeoHMatrix* mothersupplycardmatrix[7];
6249 Int_t index[4] = {1,1,1,1};
6250 for(Int_t i=0; i<7; i++){
6251 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6252 * (*mothersupplycardtrans));
6253 for(Int_t j=0; j<4; j++){
6255 case 0: //Layer5 EndCap Left Side
6256 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6257 cardinterfacematrix[i]);
6259 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6260 mothersupplycardmatrix[i]);
6265 case 1: //Layer5 EndCap Rigth Side
6266 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6267 cardinterfacematrix[i]);
6269 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6270 mothersupplycardmatrix[i]);
6274 case 2: //Layer6 EndCap Left Side
6275 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6276 cardinterfacematrix[i]);
6278 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6279 mothersupplycardmatrix[i]);
6283 case 3: //Layer6 EndCap Right Side
6284 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6285 cardinterfacematrix[i]);
6286 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6287 mothersupplycardmatrix[i]);
6293 // Positioning Interface
6294 TGeoTranslation* motherinterfacecardtrans =
6295 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6296 +0.5*fgkEndCapCardElectBoardBackThickness
6297 -fgkEndCapCardElectBoardLayerThickness
6298 +fgkEndCapStripConnectionThickness,0.,0.);
6299 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6300 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6301 // Positioning Interface Card B
6302 TGeoTranslation* interfacecardBmothertrans =
6303 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6304 + 2.*fgkEndCapStripConnectionThickness
6305 + fgkEndCapCardElectBoardBackThickness,0.,
6306 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6307 - fgkEndCapCardElectBoardBackLength[0]));
6308 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6309 interfacecardBmothertrans);
6310 // Positioning Stiffener
6311 TGeoTranslation* endcapstiffenertrans =
6312 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6313 + 2.0*fgkEndCapStripConnectionThickness
6314 + fgkEndCapInterfaceCardBThickness
6315 + fgkEndCapCardJMDConnectorLength[0]
6317 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6318 endcapstiffenershape->GetDZ()
6319 - 0.5*(fgkEndCapStiffenerLength
6320 - fgkEndCapCardElectBoardBackLength[0]));
6321 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6322 /////////////////////////////////////////////////////////////
6323 // Deallocating memory
6324 /////////////////////////////////////////////////////////////
6325 delete interfacecardBrot;
6326 delete interfacecardBtrans;
6327 delete electboardcardBtrans;
6328 delete electboardcardBrot;
6329 delete jmdconnectorcardBrot;
6330 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6331 delete jmdconnectorot;
6332 delete jmdconnectortrans[1];
6333 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6334 delete cableconnectorcombitrans;
6335 delete electboardbacktrans;
6336 delete electboardbackrot;
6337 delete electlayerrot;
6338 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6339 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6340 delete mothersupplycardtrans;
6341 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6342 /////////////////////////////////////////////////////////////
6343 return cardinterfacecontainer;
6345 ////////////////////////////////////////////////////////////////////////////////
6346 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6347 /////////////////////////////////////////////////////////////
6348 // Method returning EndCap Mother Volume
6349 /////////////////////////////////////////////////////////////
6350 const Int_t kendcapcoverplatesmallholenumber = 9;
6351 Double_t endcapmotherorigin[3];
6352 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6353 + 0.5 *(fgkEndCapCoverPlateLength[3]
6354 + 2.0 * fgkEndCapCoverPlateLength[2]);
6355 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6356 - fgkEndCapCoverPlateWidth[2]
6357 - (kendcapcoverplatesmallholenumber-1)
6358 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6359 + 0.5*(fgkEndCapSideCoverLength[2]
6360 + fgkEndCapCoverPlateWidth[1]
6361 - fgkEndCapCoverPlateWidth[0])
6362 - (fgkEndCapCoverPlateWidth[1]
6363 - fgkEndCapCoverPlateWidth[0]);
6364 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6365 + 2.*fgkEndCapCoolingTubeRadiusMax
6366 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6367 + fgkEndCapSideCoverWidth[1]
6368 + fgkEndCapSideCoverThickness
6369 + fgkEndCapKaptonFoilThickness);
6370 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6371 + 2.0* fgkEndCapCoverPlateLength[2]
6372 + 2.0* fgkEndCapSideCoverThickness),
6373 0.5* (fgkEndCapSideCoverLength[2]
6374 + fgkEndCapCoverPlateWidth[1]
6375 - fgkEndCapCoverPlateWidth[0]),
6376 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6377 + fgkEndCapSideCoverWidth[1]
6378 + fgkEndCapSideCoverThickness
6379 + fgkEndCapKaptonFoilThickness),
6380 endcapmotherorigin);
6381 TGeoVolume** endcapassembly;
6382 endcapassembly = new TGeoVolume*[4];
6383 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6384 endcapmothershape,fSSDAir);
6385 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6386 endcapmothershape,fSSDAir);
6387 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6388 endcapmothershape,fSSDAir);
6389 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6390 endcapmothershape,fSSDAir);
6391 /////////////////////////////////
6392 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6393 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6394 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6395 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6396 /////////////////////////////////
6397 /////////////////////////////////////////////////////
6398 // Placing Endcap Cover Plate
6399 /////////////////////////////////////////////////////
6400 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6401 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6402 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6403 TGeoCombiTrans* endcapcoverplatecombitrans =
6404 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6405 endcapcoverplaterot);
6406 TGeoTranslation* endcapcoverplatetrans =
6407 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6408 TGeoHMatrix* endcapcoverplatematrix =
6409 new TGeoHMatrix((*endcapcoverplatetrans)
6410 * (*endcapcoverplatecombitrans));
6411 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6412 /////////////////////////////////////////////////////
6413 // Placing Endcap Side Cover
6414 /////////////////////////////////////////////////////
6415 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6416 TGeoRotation* endcapsidecoverot[2];
6417 TGeoCombiTrans* endcapsidecovercombitrans[3];
6418 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6419 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6420 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6421 - 0.5*(fgkEndCapCoverPlateWidth[0]
6422 - fgkEndCapCoverPlateWidth[2]
6423 - (kendcapcoverplatesmallholenumber-1)
6424 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6425 + 0.*fgkEndCapCoverPlateWidth[0]
6426 + fgkEndCapSideCoverLength[2],
6427 0.5*(fgkEndCapSideCoverThickness
6428 + fgkEndCapCoverPlateThickness)
6429 - 0.5*fgkEndCapCoverPlateThickness,
6430 endcapsidecoverot[0]);
6431 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6432 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6433 0.5*fgkEndCapCoverPlateThickness
6434 -fgkEndCapSideCoverWidth[1],
6435 endcapsidecoverot[1]);
6436 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6437 +fgkEndCapCoverPlateLength[3]
6438 +2.*fgkEndCapCoverPlateLength[2]
6439 +fgkEndCapSideCoverThickness,0.0,
6440 0.5*fgkEndCapCoverPlateThickness
6441 -fgkEndCapSideCoverWidth[1],
6442 endcapsidecoverot[1]);
6443 TGeoHMatrix* endcapsidecovermatrix[2];
6444 for(Int_t i=0; i<2; i++){
6445 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6446 * (*endcapsidecovercombitrans[0]));
6447 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6448 endcapsidecovermatrix[i]);
6450 /////////////////////////////////////////////////////
6451 // Placing Endcap Cooling Tube
6452 /////////////////////////////////////////////////////
6453 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6454 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6455 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6456 TGeoCombiTrans* endcapccolingtubecombitrans
6457 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6458 + fgkEndCapCoolingTubeAxialRadius[1])
6459 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6460 - fgkEndCapCoolingTubeToCoverSide,
6461 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6462 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6463 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6464 endcapccolingtubecombitrans);
6465 /////////////////////////////////////////////////////
6467 /////////////////////////////////////////////////////
6468 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6469 fgkEndCapCoverPlateScrewRadiusMin};
6470 Int_t screwcoverplatedgesnumber[2] = {20,20};
6471 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6472 fgkEndCapCoverPlateThickness
6473 + fgkEndCapCoolingTubeRadiusMax};
6474 TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6475 screwcoverplatedgesnumber,
6476 screwcoverplatesection);
6477 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6478 screwcoverplateshape,
6479 fSSDCoolingTubePhynox);
6480 screwcoverplate->SetLineColor(12);
6481 Double_t transx[4] = {0,
6482 fgkEndCapCoverPlateSmallHoleSeparation[0],
6483 fgkEndCapCoverPlateSmallHoleSeparation[0]
6484 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6485 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6486 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6487 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6488 // TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6489 TGeoTranslation*** endcapcoverplatescrewtrans;
6490 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6492 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6493 endcapcoverplatescrewtrans[i] =
6494 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6495 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6496 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6497 if(index==1||index==9||index==28||index==36){
6498 endcapcoverplatescrewtrans[i][j] =
6499 new TGeoTranslation(transx[i],
6500 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6501 fgkEndCapSideCoverThickness);
6504 endcapcoverplatescrewtrans[i][j] =
6505 new TGeoTranslation(transx[i],
6506 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6510 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6511 endcapcoverplatescrewtrans[i][j]);
6514 /////////////////////////////////////////////////////
6515 // Placing Cover Plate Clips
6516 /////////////////////////////////////////////////////
6517 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6518 0.5*fgkEndCapCoverPlateClipWidth,
6519 0.5*fgkEndCapSideCoverThickness);
6520 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6521 endcapcoverplateclipshape,
6522 fSSDCoolingTubePhynox);
6523 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6524 0.5*fgkEndCapCoverPlateDownClipWidth,
6525 0.5*fgkEndCapSideCoverThickness);
6526 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6527 endcapcoverplatedownclipshape,
6528 fSSDCoolingTubePhynox);
6529 TGeoTranslation* endcapcoverplatecliptrans[4];
6530 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6531 - fgkEndCapCoverPlateLength[0]
6532 - fgkEndCapSideCoverThickness,
6534 0.5*(fgkEndCapSideCoverThickness
6535 + fgkEndCapCoverPlateThickness));
6536 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6537 - fgkEndCapCoverPlateLength[0]
6538 - fgkEndCapSideCoverThickness,
6539 (kendcapcoverplatescrewnumber[1]-1)
6540 * fgkEndCapSideCoverWidth[5],
6541 0.5*(fgkEndCapSideCoverThickness
6542 + fgkEndCapCoverPlateThickness));
6543 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6544 - fgkEndCapCoverPlateLength[0]
6545 + fgkEndCapCoverPlateLength[1]
6546 + 2.*fgkEndCapCoverPlateLength[0]
6547 - fgkEndCapCoverPlateClipLength
6548 + fgkEndCapSideCoverThickness,
6550 0.5*(fgkEndCapSideCoverThickness
6551 + fgkEndCapCoverPlateThickness));
6552 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6553 - fgkEndCapCoverPlateLength[0]
6554 + fgkEndCapCoverPlateLength[1]
6555 + 2.*fgkEndCapCoverPlateLength[0]
6556 - fgkEndCapCoverPlateClipLength
6557 + fgkEndCapSideCoverThickness,
6558 (kendcapcoverplatescrewnumber[1]-1)
6559 * fgkEndCapSideCoverWidth[5],
6560 0.5*(fgkEndCapSideCoverThickness
6561 + fgkEndCapCoverPlateThickness));
6562 endcapcoverplateclip->SetLineColor(fColorPhynox);
6563 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6564 for(Int_t i=0; i<4; i++)
6565 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6566 endcapcoverplatecliptrans[i]);
6567 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6568 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6569 - fgkEndCapCoverPlateLength[0]
6570 - fgkEndCapSideCoverThickness,
6571 0.5*(fgkEndCapCoverPlateDownClipWidth
6572 - fgkEndCapCoverPlateClipWidth),
6573 0.5*(fgkEndCapSideCoverThickness
6574 + fgkEndCapCoverPlateThickness)
6575 - fgkEndCapSideCoverWidth[1]
6576 - fgkEndCapSideCoverThickness);
6577 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6578 - fgkEndCapCoverPlateLength[0]
6579 - fgkEndCapSideCoverThickness,
6580 0.5*(fgkEndCapCoverPlateDownClipWidth
6581 - fgkEndCapCoverPlateClipWidth)
6582 + fgkEndCapSideCoverLength[2]
6583 - fgkEndCapCoverPlateDownClipWidth,
6584 0.5*(fgkEndCapSideCoverThickness
6585 + fgkEndCapCoverPlateThickness)
6586 - fgkEndCapSideCoverWidth[1]
6587 - fgkEndCapSideCoverThickness);
6588 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6589 - fgkEndCapCoverPlateLength[0]
6590 + fgkEndCapSideCoverThickness
6591 + fgkEndCapCoverPlateLength[1]
6592 + 2.0*fgkEndCapCoverPlateLength[0]
6593 - fgkEndCapCoverPlateDownClipLength,
6594 0.5*(fgkEndCapCoverPlateDownClipWidth
6595 - fgkEndCapCoverPlateClipWidth),
6596 0.5*(fgkEndCapSideCoverThickness
6597 + fgkEndCapCoverPlateThickness)
6598 - fgkEndCapSideCoverWidth[1]
6599 - fgkEndCapSideCoverThickness);
6600 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6601 - fgkEndCapCoverPlateLength[0]
6602 + fgkEndCapSideCoverThickness
6603 + fgkEndCapCoverPlateLength[1]
6604 + 2.0*fgkEndCapCoverPlateLength[0]
6605 - fgkEndCapCoverPlateDownClipLength,
6606 0.5*(fgkEndCapCoverPlateDownClipWidth
6607 - fgkEndCapCoverPlateClipWidth)
6608 + fgkEndCapSideCoverLength[2]
6609 - fgkEndCapCoverPlateDownClipWidth,
6610 0.5*(fgkEndCapSideCoverThickness
6611 + fgkEndCapCoverPlateThickness)
6612 - fgkEndCapSideCoverWidth[1]
6613 - fgkEndCapSideCoverThickness);
6614 for(Int_t i=0; i<4; i++)
6615 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6616 endcapcoverplatedowncliptrans[i]);
6617 /////////////////////////////////////////////////////
6618 // Placing Kapton Foil
6619 /////////////////////////////////////////////////////
6620 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6621 0.5*fgkEndCapKaptonFoilWidth,
6622 0.5*fgkEndCapKaptonFoilThickness);
6623 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6624 endcapkaptonfoilshape,
6625 fSSDKaptonFlexMedium);
6626 endcapkaptonfoil->SetLineColor(8);
6627 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6628 0.5*fgkEndCapKaptonFoilWidth
6629 - 0.5*fgkEndCapCoverPlateClipWidth,
6630 0.5*fgkEndCapCoverPlateThickness
6631 - 0.5*fgkEndCapKaptonFoilThickness
6632 - fgkEndCapSideCoverWidth[1]
6633 - fgkEndCapSideCoverThickness);
6634 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6635 /////////////////////////////////////////////////////////////
6636 // Placing Electronic Tubes
6637 /////////////////////////////////////////////////////////////
6638 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6639 - fgkEndCapInterfaceCardBThickness
6640 - 9.*fgkEndCapStripConnectionThickness
6641 - 8.*fgkEndCapCardElectBoardBackThickness,
6642 fgkEndCapKaptonFoilWidth
6643 - fgkEndCapInterfaceCardBThickness
6644 - 9.*fgkEndCapStripConnectionThickness
6645 - 8.*fgkEndCapCardElectBoardBackThickness
6646 - fgkEndCapInterfaceElectBoardCardBThickness};
6647 TGeoVolume* endcapeffectivecables[2];
6648 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6649 fgkEndCapEffectiveCableRadiusMax,
6650 endcapeffectivecableswidth[0],
6651 10,"EndCapEffectiveCables1");
6652 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6653 fgkEndCapEffectiveCableRadiusMax,
6654 endcapeffectivecableswidth[1],
6655 25,"EndCapEffectiveCables2");
6656 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6657 TGeoTranslation* endcapeffectivecablestrans[2];
6658 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6659 - 0.5*endcapeffectivecableswidth[0]
6660 - 0.5*(fgkEndCapCoverPlateWidth[0]
6661 - fgkEndCapCoverPlateWidth[2]
6662 - (kendcapcoverplatesmallholenumber-1)
6663 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6664 + fgkEndCapSideCoverLength[2],
6665 - 0.5*fgkEndCapCoverPlateThickness
6666 - (fgkEndCapCardElectBoardBackWidth[0]
6667 - fgkEndCapInterfaceCardBWidth[0]
6668 - fgkEndCapInterfaceCardBWidth[1]));
6669 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6670 - 0.5*endcapeffectivecableswidth[1]
6671 - 0.5*(fgkEndCapCoverPlateWidth[0]
6672 - fgkEndCapCoverPlateWidth[2]
6673 - (kendcapcoverplatesmallholenumber-1)
6674 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6675 + fgkEndCapSideCoverLength[2],
6676 - 0.5*fgkEndCapCoverPlateThickness
6677 - (fgkEndCapCardElectBoardBackWidth[0]
6678 - fgkEndCapInterfaceCardBWidth[0])
6679 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6680 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6681 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6682 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6683 *endcapeffectivecablesrot);
6684 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6685 *endcapeffectivecablesrot);
6686 // for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6687 // endcapeffectivecablescombitrans[0]);
6688 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6689 endcapeffectivecablescombitrans[1]);
6690 /////////////////////////////////////////////////////////////
6691 // Placing End Cap Cards
6692 /////////////////////////////////////////////////////////////
6693 TGeoVolume** endcapcards = GetEndCapCards();
6694 TGeoRotation* endcapcardsrot[2];
6695 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6696 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6697 TGeoTranslation* endcapcardstrans[2];
6698 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6699 - fgkEndCapCardElectBoardBackLength[0]));
6700 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6701 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6702 TGeoHMatrix* endcapcardsmatrix[2];
6703 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6704 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6705 - fgkEndCapCardJMDConnectorLength[0]
6706 - fgkEndCapInterfaceCardBThickness
6707 - 9.*fgkEndCapStripConnectionThickness
6708 - 8.*fgkEndCapCardElectBoardBackThickness;
6709 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6710 - fgkEndCapCoverPlateLength[0]
6711 + 0.5 * (fgkEndCapCoverPlateLength[3]
6712 + 2.0 * fgkEndCapCoverPlateLength[2]),
6713 - stiffenertransx-fgkEndCapStiffenerWidth
6714 - fgkEndCapCardJMDConnectorLength[0]
6715 - fgkEndCapInterfaceCardBThickness
6716 - 2.0 * fgkEndCapStripConnectionThickness
6717 - 1.5 * fgkEndCapInterfaceCardBThickness
6718 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6719 - fgkEndCapCoverPlateWidth[2]
6720 - (kendcapcoverplatesmallholenumber-1)
6721 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6722 + fgkEndCapKaptonFoilWidth,
6723 0.5*fgkEndCapCoverPlateThickness
6724 - fgkEndCapSideCoverWidth[1]);
6725 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6726 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6727 /////////////////////////////////////////////////////////////
6728 // Deallocating memory
6729 /////////////////////////////////////////////////////////////
6730 delete endcapcoverplaterot;
6731 delete endcapcoverplatecombitrans;
6732 delete endcapcoverplatetrans;
6733 for(Int_t i=0; i<3; i++){
6734 delete endcapsidecovercombitrans[i];
6735 if(i<2) delete endcapsidecoverot[i];
6737 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6738 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6739 delete endcapcardsmatrix[0];
6740 return endcapassembly;
6742 ////////////////////////////////////////////////////////////////////////////////
6743 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6747 const char* volname){
6748 /////////////////////////////////////////////////////////////
6749 // Generating EndCap High Voltage Tubes
6750 /////////////////////////////////////////////////////////////
6751 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6752 Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6754 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6755 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6756 effectiveouteradius,0.5*width);
6757 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6758 effectiveinnertubeshape,
6759 fSSDStiffenerConnectorMedium);
6760 effectiveinnertube->SetLineColor(41);
6761 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6762 effectiveoutertubeshape,
6763 fSSDKaptonChipCableMedium);
6764 effectiveoutertube->SetLineColor(39);
6765 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6766 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6767 effectivemothertube->AddNode(effectiveinnertube,1);
6768 effectivemothertube->AddNode(effectiveoutertube,1);
6769 return effectivemothertube;
6771 ////////////////////////////////////////////////////////////////////////////////
6772 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6773 /////////////////////////////////////////////////////////////
6774 // Generating EndCap Support Layer 5 and Layer 6
6775 /////////////////////////////////////////////////////////////
6776 const Int_t knedges = 5;
6777 ///////////////////////////////////////////////
6778 // Setting the vertices for TGeoXtru Up Volume
6779 ///////////////////////////////////////////////
6780 const Int_t klayernumber = 2;
6781 Double_t xupvertex[klayernumber][knedges+3];
6782 Double_t yupvertex[klayernumber][knedges+3];
6783 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6784 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6785 Double_t middlepsi[klayernumber] = {0.0,0.0};
6786 for(Int_t i=0; i<klayernumber; i++){
6787 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6788 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6789 xupvertex[i][2] = -xupvertex[i][1];
6790 xupvertex[i][3] = -xupvertex[i][0];
6792 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6793 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6794 yupvertex[i][2] = yupvertex[i][1];
6795 yupvertex[i][3] = yupvertex[i][0];
6797 middledgeangle[i] = upedgeangle[i]/knedges;
6798 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6799 for(Int_t j=1; j<knedges; j++){
6800 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6801 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6804 ////////////////////////////////////
6805 // Generating Up TGeoXtru
6806 ////////////////////////////////////
6807 TGeoXtru* upendcapsupportshape[klayernumber];
6808 TGeoVolume* upendcapsupport[klayernumber];
6809 char upendcapsupportname[100];
6810 for(Int_t i=0; i<klayernumber; i++){
6811 upendcapsupportshape[i] = new TGeoXtru(2);
6812 sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6813 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6814 upendcapsupportshape[i]->DefineSection(0,0.);
6815 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6816 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
6818 upendcapsupport[i]->SetLineColor(5);
6820 ///////////////////////////////////////////////
6821 // Setting the vertices for TGeoXtru Down Volume
6822 ///////////////////////////////////////////////
6823 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6824 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6825 for(Int_t i=0; i<klayernumber; i++){
6826 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6827 xdownvertex[i][1] = xupvertex[i][0];
6828 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6829 ydownvertex[i][1] = yupvertex[i][0];
6830 for(Int_t j=0; j<knedges; j++){
6831 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6832 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6834 for(Int_t j=0; j<knedges; j++){
6835 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6836 * CosD(middlepsi[i]+j*middledgeangle[i]);
6837 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6838 * SinD(middlepsi[i]+j*middledgeangle[i]);
6841 ////////////////////////////////////
6842 // Generating Down TGeoXtru
6843 ////////////////////////////////////
6844 TGeoXtru* downendcapsupportshape[klayernumber];
6845 TGeoVolume* downendcapsupport[klayernumber];
6846 char downendcapsupportname[100];
6847 for(Int_t i=0; i<klayernumber; i++){
6848 downendcapsupportshape[i] = new TGeoXtru(2);
6849 sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
6850 downendcapsupportshape[i] = new TGeoXtru(2);
6851 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6853 downendcapsupportshape[i]->DefineSection(0,0.);
6854 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6857 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6858 - fgkEndCapSupportLowWidth[i]);
6859 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6861 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
6862 downendcapsupportshape[i],fSSDSupportRingAl);
6863 downendcapsupport[i]->SetLineColor(5);
6865 ///////////////////////////////////////////////
6866 // Setting TGeoPgon Volume
6867 ///////////////////////////////////////////////
6868 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6869 fgkSSDLay6LadderNumber};
6870 TGeoPgon* endcapsupportmothershape[klayernumber];
6871 TGeoVolume** endcapsupportmother;
6872 endcapsupportmother = new TGeoVolume*[klayernumber];
6873 char endcapsupportmothername[100];
6874 for(Int_t i=0; i<klayernumber; i++){
6875 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6876 sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
6877 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6878 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6879 ydownvertex[i][0],yupvertex[i][1]);
6880 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
6883 ////////////////////////////////////
6884 TGeoRotation** endcapsupportrot[klayernumber];
6885 for(Int_t i=0; i<2; i++){
6886 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6887 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6888 endcapsupportrot[i][j] = new TGeoRotation();
6889 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6890 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6891 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6894 return endcapsupportmother;
6896 ////////////////////////////////////////////////////////////////////////////////
6897 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6898 /////////////////////////////////////////////////////////////
6899 // Setting End Cap Support Layer 5 and 6.
6900 /////////////////////////////////////////////////////////////
6901 const Int_t kendcapcoverplatesmallholenumber = 9;
6902 const Int_t klayernumber = 2;
6903 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6904 fgkSSDLay6LadderNumber};
6905 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6906 360.0/kssdlayladdernumber[1]};
6907 TGeoVolume** endcapsupport = EndCapSupport();
6908 TGeoVolume** endcapassembly = GetEndCapAssembly();
6909 TGeoPgon* endcapsupportshape[klayernumber];
6910 Double_t* radiusmin[klayernumber];
6911 Double_t* radiusmax[klayernumber];
6912 for(Int_t i=0; i<klayernumber; i++){
6913 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6914 radiusmin[i] = endcapsupportshape[i]->GetRmin();
6915 radiusmax[i] = endcapsupportshape[i]->GetRmax();
6917 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6918 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6919 endcapassemblyshape->GetDY(),
6920 endcapassemblyshape->GetDZ()};
6921 ///////////////////////////////////////////////
6922 // Setting TGeoPgon Volume for Mother Container
6923 ///////////////////////////////////////////////
6924 TGeoPgon* endcapsupportsystemshape[klayernumber];
6925 char endcapsupportsystemothername[100];
6926 for(Int_t i=0; i<klayernumber; i++){
6927 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6928 sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
6929 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
6930 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
6931 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6932 +2.*endcapassemblycenter[2])
6933 /CosD(0.5*upedgeangle[i]));
6934 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
6935 -(fgkEndCapCoverPlateWidth[1]
6936 - fgkEndCapCoverPlateWidth[0]),
6938 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6939 +2.*endcapassemblycenter[2])
6940 /CosD(0.5*upedgeangle[i]));
6942 fgkEndCapSupportSystem = new TGeoVolume*[4];
6943 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
6944 endcapsupportsystemshape[0],fSSDAir);
6945 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
6946 endcapsupportsystemshape[0],fSSDAir);
6947 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
6948 endcapsupportsystemshape[1],fSSDAir);
6949 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
6950 endcapsupportsystemshape[1],fSSDAir);
6951 ///////////////////////////////////////////////
6952 TGeoTranslation* endcapassemblytrans[klayernumber];
6953 for(Int_t i=0; i<klayernumber; i++)
6954 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
6955 - fgkEndCapSideCoverThickness
6956 + endcapassemblycenter[0],
6957 - 0.5*fgkEndCapCoverPlateThickness
6958 - 2.0*fgkEndCapCoolingTubeRadiusMax
6959 + 2.0*endcapassemblycenter[2]
6960 + 0.5*fgkEndCapSupportLength[i]
6961 / TanD(0.5*upedgeangle[i]),
6962 0.5*(fgkEndCapCoverPlateWidth[0]
6963 - fgkEndCapCoverPlateWidth[2]
6964 - (kendcapcoverplatesmallholenumber-1)
6965 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
6966 TGeoRotation** endcapassemblyrot[klayernumber];
6967 TGeoHMatrix** endcapassemblymatrix[klayernumber];
6968 for(Int_t i=0; i<klayernumber; i++){
6969 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
6970 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
6971 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
6972 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
6973 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
6974 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
6975 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
6976 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6977 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
6978 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
6981 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
6982 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
6983 for(Int_t i=0; i<2*klayernumber; i++){
6984 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
6985 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
6986 endcapassemblymatrix[1][j+2]);
6988 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
6990 /////////////////////////////////////////////////////////////
6991 // Deallocating memory
6992 /////////////////////////////////////////////////////////////
6993 for(Int_t i=0; i<klayernumber; i++){
6994 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
6995 delete endcapassemblyrot[i][j];
6997 delete [] endcapassemblyrot[i];
6998 delete endcapassemblymatrix[i][0];
6999 delete endcapassemblymatrix[i][1];
7001 /////////////////////////////////////////////////////////////
7003 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7004 /////////////////////////////////////////////////////////////
7005 // Setting End Cap Support + End Cap Assembly of Layer 5.
7006 /////////////////////////////////////////////////////////////
7008 AliError("Can't insert end cap support of layer5, mother is null!\n");
7011 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7012 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7013 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7014 fgkEndCapSupportCenterLay5ITSPosition
7015 + fgkEndCapSupportCenterLay5Position
7016 - fgkEndCapSideCoverLength[2]);
7017 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7018 fgkEndCapSideCoverLength[2]
7019 - fgkEndCapSupportCenterLay5Position
7020 - fgkEndCapSupportCenterLay5ITSPosition);
7021 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7022 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7023 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7024 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7025 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7026 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7027 /////////////////////////////////////////////////////////////
7028 // Deallocating memory
7029 /////////////////////////////////////////////////////////////
7030 delete endcapsupportsystemrot;
7031 delete endcapsupportsystemITSCentertrans[1];
7033 /////////////////////////////////////////////////////////////
7034 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7035 /////////////////////////////////////////////////////////////
7036 // Setting End Cap Support + End Cap Assembly of Layer 6.
7037 /////////////////////////////////////////////////////////////
7039 AliError("Can't insert end cap support of layer6, mother is null!\n");
7042 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
7043 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7044 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7045 fgkEndCapSupportCenterLay6ITSPosition
7046 + fgkEndCapSupportCenterLay6Position
7047 - fgkEndCapSideCoverLength[2]);
7048 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7049 fgkEndCapSideCoverLength[2]
7050 - fgkEndCapSupportCenterLay6Position
7051 - fgkEndCapSupportCenterLay6ITSPosition);
7052 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7053 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7054 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7055 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7056 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7057 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7058 /////////////////////////////////////////////////////////////
7059 // Deallocating memory
7060 /////////////////////////////////////////////////////////////
7061 delete endcapsupportsystemrot;
7062 delete endcapsupportsystemITSCentertrans[1];
7064 ////////////////////////////////////////////////////////////////////////////////
7065 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7066 /////////////////////////////////////////////////////////////
7067 // Setting Ladder Support of Layer 5.
7068 /////////////////////////////////////////////////////////////
7070 AliError("Can't insert ladder lupport of layer5, mother is null!\n");
7073 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7075 TGeoTranslation* centerITSRingSupportLay5trans[2];
7076 for(Int_t i=0; i<2; i++){
7077 centerITSRingSupportLay5trans[i] =
7078 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7079 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7082 ////////////////////////////////////////////////////////////////////////////////
7083 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7084 /////////////////////////////////////////////////////////////
7085 // Setting Ladder Support of Layer 6.
7086 /////////////////////////////////////////////////////////////
7088 AliError("Can't insert ladder lupport of layer6, mother is null!\n");
7091 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7093 TGeoTranslation* centerITSRingSupportLay6trans[2];
7094 for(Int_t i=0; i<2; i++){
7095 centerITSRingSupportLay6trans[i] =
7096 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7097 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7100 ////////////////////////////////////////////////////////////////////////////////
7101 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7102 /////////////////////////////////////////////////////////////
7103 // Setting Ladder Support of Layer 6.
7104 /////////////////////////////////////////////////////////////
7106 AliError("Can't insert SSD Cone, mother is null!\n");
7109 if(!fSSDCone) SetSSDCone();
7110 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7111 + fgkSSDCentralAL3SupportLength);
7112 moth->AddNode(fSSDCone,1,ssdconetrans);
7114 ////////////////////////////////////////////////////////////////////////////////
7115 void AliITSv11GeometrySSD::SetSSDCone(){
7116 /////////////////////////////////////////////////////////////
7117 // Method generating SSDCone
7118 /////////////////////////////////////////////////////////////
7119 if(!fCreateMaterials) CreateMaterials();
7120 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7121 Double_t ssdpconesectionradiusmax[16];
7122 Double_t ssdpconesectionradiusmin[16];
7123 Double_t ssdpconezsection[16];
7124 TGeoPcon* ssdpconelittleholeshape[8];
7125 TGeoVolume* ssdpconelittlehole[8];
7126 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7127 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7128 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7129 / SinD(fgkSSDPConeAngle)
7130 + ssdpconesectionradiusmin[0];
7131 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7132 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7133 / SinD(fgkSSDPConeAngle);
7134 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7135 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7136 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7137 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7138 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7139 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7140 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7141 ssdpconelittlehole[0]->SetLineColor(4);
7142 /////////////////////////////////////////////////////////////
7143 ssdpconezsection[2] = ssdpconezsection[1];
7144 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7145 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7146 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7147 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7148 / SinD(fgkSSDPConeAngle);
7149 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7150 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7151 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7152 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7153 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7154 * TMath::RadToDeg();
7155 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7156 60.-ssdpconelittleholeangle,2);
7157 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7158 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7159 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7160 ssdpconelittlehole[1]->SetLineColor(4);
7161 TGeoRotation* ssdconelittleholerot[6];
7162 for(Int_t i=0; i<6; i++){
7163 ssdconelittleholerot[i] = new TGeoRotation();
7164 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7166 /////////////////////////////////////////////////////////////
7167 ssdpconezsection[4] = ssdpconezsection[3];
7168 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7169 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7170 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7171 * CosD(fgkSSDPConeAngle)
7172 / SinD(fgkSSDPConeAngle);
7173 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7174 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7175 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7176 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7177 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7178 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7179 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7180 ssdpconelittlehole[2]->SetLineColor(4);
7181 ///////////////////////////////////////////////////
7182 ssdpconezsection[6] = ssdpconezsection[5];
7183 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7184 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7185 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7186 -ssdpconezsection[0]
7187 * CosD(fgkSSDPConeAngle)
7188 / SinD(fgkSSDPConeAngle);
7189 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7190 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7191 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7192 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7193 * TMath::RadToDeg();
7194 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7195 45.-ssdpconemiddleholeangle,2);
7196 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7197 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7198 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7199 ssdpconelittlehole[3]->SetLineColor(4);
7200 TGeoRotation* ssdconemiddleholerot[8];
7201 for(Int_t i=0; i<8; i++){
7202 ssdconemiddleholerot[i] = new TGeoRotation();
7203 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7205 /////////////////////////////////////////////////////////////
7206 ssdpconezsection[8] = ssdpconezsection[7];
7207 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7208 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7209 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7210 * CosD(fgkSSDPConeAngle)
7211 / SinD(fgkSSDPConeAngle);
7212 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7213 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7214 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7215 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7216 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7217 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7218 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7219 ssdpconelittlehole[4]->SetLineColor(4);
7220 /////////////////////////////////////////////////////////////
7221 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7222 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7223 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7224 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7225 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7226 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7227 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7228 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7229 * TMath::RadToDeg();
7230 ssdpconezsection[10] = ssdpconezsection[9];
7231 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7232 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7233 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7234 * CosD(fgkSSDPConeAngle)
7235 / SinD(fgkSSDPConeAngle);
7236 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7237 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7238 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7239 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7240 ssdpconetrapezoidsectionangle,2);
7241 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7242 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7243 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7244 ssdpconelittlehole[5]->SetLineColor(4);
7245 TGeoRotation* ssdconeupradiusrot[8];
7246 for(Int_t i=0; i<8; i++){
7247 ssdconeupradiusrot[i] = new TGeoRotation();
7248 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7250 /////////////////////////////////////////////////////////////
7251 ssdpconezsection[12] = ssdpconezsection[11];
7252 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7253 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7254 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7255 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7256 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7257 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7258 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7259 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7260 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7261 ssdpconelittlehole[6]->SetLineColor(4);
7262 /////////////////////////////////////////////////////////////
7263 ssdpconezsection[14] = 0.0;
7264 ssdpconezsection[15] = ssdpconezsection[0];
7265 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7266 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7267 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7268 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7269 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7270 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7271 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7272 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7273 ssdpconelittlehole[7]->SetLineColor(4);
7274 /////////////////////////////////////////////////////////////
7275 TGeoTube* ssdtubeconeshape[2];
7276 TGeoVolume* ssdtubecone[2];
7277 TGeoTranslation* ssdtubeconetrans[2];
7278 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7279 fgkSSDPConeExternalRadius,
7280 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7281 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7282 0.5*ssdpconezsection[0]);
7283 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7284 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7285 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7286 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7287 + ssdpconezsection[13]);
7288 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7289 ssdtubecone[0]->SetLineColor(4);
7290 ssdtubecone[1]->SetLineColor(4);
7291 /////////////////////////////////////////////////////////////
7292 // Mother Volume Container
7293 /////////////////////////////////////////////////////////////
7294 Double_t ssdconemotherradiusmin[8];
7295 Double_t ssdconemotherradiusmax[8];
7296 Double_t ssdconemothersection[8];
7297 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7298 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7299 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7300 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7301 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7302 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7303 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7304 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7305 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7306 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7307 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7308 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7309 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7310 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7311 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7312 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7313 ssdconemothersection[0] = 0.0;
7314 ssdconemothersection[1] = ssdpconezsection[0];
7315 ssdconemothersection[2] = ssdpconezsection[0];
7316 ssdconemothersection[3] = ssdpconezsection[11];
7317 ssdconemothersection[4] = ssdpconezsection[11];
7318 ssdconemothersection[5] = ssdpconezsection[13];
7319 ssdconemothersection[6] = ssdpconezsection[13];
7320 ssdconemothersection[7] = fgkSSDPConeLength;
7321 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7322 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7323 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7324 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7325 /////////////////////////////////////////////////////////////
7326 //Placing the Volumes into Mother
7327 /////////////////////////////////////////////////////////////
7328 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7329 for(Int_t i=0; i<6; i++){
7330 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7332 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7333 for(Int_t i=0; i<8; i++){
7334 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7336 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7337 for(Int_t i=0; i<8; i++){
7338 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7340 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7341 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7342 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7343 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7344 /////////////////////////////////////////////////////////////
7345 // ITS General Support
7346 /////////////////////////////////////////////////////////////
7347 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7348 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7349 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7350 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7351 - fgkSSDCentralAL3SupportLength);
7352 ssdcentralsupport->SetLineColor(4);
7353 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7354 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7355 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7356 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7357 TGeoTranslation* ssdcentralal3supportrans[3];
7358 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7359 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7360 - 1.25*fgkSSDCentralAL3SupportLength);
7361 ssdcentralal3support->SetLineColor(4);
7362 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7363 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7364 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7365 Double_t ssdpconcentralradiusmin[2];
7366 Double_t ssdpconcentralradiusmax[2];
7367 Double_t ssdpconcentralsection[2];
7368 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7369 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7370 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7371 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7372 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7373 ssdpconcentralsection[1] = 0.;
7374 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7375 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7376 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7377 ssdpconcentralal3->SetLineColor(4);
7378 fSSDCone->AddNode(ssdpconcentralal3,1);
7379 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7380 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7381 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7382 -2.*fgkSSDCentralAL3SupportLength);
7383 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7384 *ssdcentralal3supportrot);
7385 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7386 TGeoRotation* ssdconemotherot = new TGeoRotation();
7387 ssdconemotherot->SetAngles(90.,180.,-90.);
7388 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7389 -2.*fgkSSDCentralAL3SupportLength);
7390 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7391 fSSDCone->AddNode(ssdconemother,1);
7392 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7393 /////////////////////////////////////////////////////////////
7394 // Deallocating memory
7395 /////////////////////////////////////////////////////////////
7396 delete ssdcentralal3supportrot;
7397 delete ssdcentralal3supportrans[2];
7398 delete ssdconemotherot;
7399 delete ssdconemothertrans;
7400 /////////////////////////////////////////////////////////////
7402 ////////////////////////////////////////////////////////////////////////////////
7403 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7404 /////////////////////////////////////////////////////////////
7405 // Setting SSD Cables
7406 /////////////////////////////////////////////////////////////
7408 AliError("Can't insert SSD Cables, mother is null!\n");
7411 TGeoVolume* ssdcables = SetSSDCables();
7412 moth->AddNode(ssdcables,1);
7414 ////////////////////////////////////////////////////////////////////////////////
7415 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7416 /////////////////////////////////////////////////////////////
7417 // Method generating SSDCables
7418 /////////////////////////////////////////////////////////////
7419 // SSD Layer 5 Cables
7420 //////////////////////////////////////////////////////////////////////////////////////////////////
7421 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7422 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
7423 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
7424 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7425 //////////////////////////////////////////////////////////////////////////////////////////////////
7426 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+fgkSSDCablesLay5TubeRadiusMin;
7427 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7428 - fgkSSDLowerPConeRadius)
7429 * TanD(fgkSSDPConeAngle);
7430 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7431 + fgkEndCapSupportCenterLay5Position
7432 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7433 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7434 - ssdcableslay5startconedistance;
7435 ssdcablelay5rightsidelength *= ssdcablesfactor;
7436 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+fgkSSDCablesLay5RightSideHeight;
7437 TGeoTube* ssdcablelay5rightubeshape = new TGeoTube(ssdcableslay5rigthsideradiusmin,
7438 ssdcableslay5rightsideradiusmax,
7439 0.5*ssdcablelay5rightsidelength);
7440 TGeoVolume* ssdcablelay5righttube = new TGeoVolume("SSDCableLay5RightSideTube",
7441 ssdcablelay5rightubeshape,
7443 ssdcablelay5righttube->SetLineColor(9);
7444 TGeoTranslation* ssdcablelay5rightrans =
7445 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7446 + fgkEndCapSupportCenterLay5Position
7447 + 0.5*ssdcablelay5rightsidelength);
7448 ////////////////////////////////////
7449 // Double_t cablescapacity[20];
7450 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7451 ////////////////////////////////////
7452 ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7453 ////////////////////////////////////
7454 // TGeoPCone Volumes
7455 ///////////////////////////////////
7456 TGeoPcon* ssdcableslay5pconshape[3];
7457 TGeoVolume* ssdcableslay5pcon[3];
7458 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7459 Double_t ssdcableslay5pconzsection[6];
7460 Double_t ssdcableslay5pconrmin[6];
7461 Double_t ssdcableslay5pconrmax[6];
7462 ssdcableslay5pconrmin[0] = ssdcablelay5rightubeshape->GetRmin();
7463 ssdcableslay5pconrmax[0] = ssdcablelay5rightubeshape->GetRmax();
7464 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7465 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+fgkSSDCablesLay5RightSideHeight;
7466 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7467 + fgkEndCapSupportCenterLay5Position
7468 + 2.*ssdcablelay5rightubeshape->GetDz();
7469 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7470 + fgkSSDCentralAL3SupportLength
7471 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7472 * TanD(fgkSSDPConeAngle);
7473 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7474 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7475 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7476 ssdcableslay5pconshape[0],fSSDCopper);
7477 ssdcableslay5pcon[0]->SetLineColor(9);
7478 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7479 ////////////////////////////////////
7480 // cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7481 ////////////////////////////////////
7482 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7483 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7484 + fgkSSDCentralAL3SupportLength
7485 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7486 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7487 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7488 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7489 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7490 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7492 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7493 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7494 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7495 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7496 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7497 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3]+fgkSSDCablesLay5RightSideHeight;
7498 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7499 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7500 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7501 ssdcableslay5pcon[1]->SetLineColor(9);
7502 ////////////////////////////////////
7503 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7505 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7506 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7507 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7508 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7509 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7510 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7511 * TanD(fgkSSDPConeAngle)
7512 + 0.5*fgkSSDCentralSupportLength
7513 + fgkSSDCentralAL3SupportLength;
7514 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7515 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7516 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7517 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7518 ssdcableslay5pcon[2]->SetLineColor(9);
7519 ////////////////////////////////////
7520 TGeoRotation* ssdcableslay5pconrot[4];
7521 for(Int_t i=0; i<4; i++){
7522 ssdcableslay5pconrot[i] = new TGeoRotation();
7523 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7524 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7525 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
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 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7534 - 0.5*ssdcablelay5rightsidelength
7535 - fgkEndCapSupportCenterLay5Position
7536 - fgkEndCapSupportCenterLay5ITSPosition);
7537 ssdcablesmother->AddNode(ssdcablelay5righttube,2,ssdcablesLay5RightTubeToLeftrans);
7538 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7539 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7540 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7541 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7542 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7543 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7544 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7545 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7547 ////////////////////////////////////
7548 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7549 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7550 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7551 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7552 /////////////////////////////////////////////////////////////
7553 // Water Tubes Layer 5
7554 /////////////////////////
7555 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7556 ssdcableslay5rightsideradiusmax
7557 + fgkSSDCablesLay5RightSideWaterHeight,
7558 0.5*ssdcablelay5rightsidelength);
7559 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7560 ssdcablelay5rightubewatershape,
7561 fSSDCoolingTubeWater);
7562 ssdcablelay5rightwatertube->SetLineColor(7);
7563 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7564 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7565 ////////////////////////////////////
7566 // TGeoPCone Water Volumes Layer
7567 ///////////////////////////////////
7568 TGeoPcon* ssdcableslay5pconwatershape[3];
7569 TGeoVolume* ssdcableslay5pconwater[3];
7570 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7571 Double_t ssdcableslay5pconwaterzsection[6];
7572 Double_t ssdcableslay5pcwateronrmin[6];
7573 Double_t ssdcableslay5pconwaterrmax[6];
7574 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7575 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7576 + fgkSSDCablesLay5RightSideWaterHeight;
7577 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7578 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7579 + fgkSSDCablesLay5RightSideWaterHeight;
7580 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7581 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7582 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7583 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7584 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7585 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7586 ssdcableslay5pconwater[0]->SetLineColor(7);
7587 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7588 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7589 ////////////////////////////////////
7590 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7591 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7592 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7594 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7595 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7596 + fgkSSDCablesLay5RightSideWaterHeight;
7597 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7598 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7599 + fgkSSDCablesLay5RightSideWaterHeight;
7600 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7601 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7602 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7603 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7604 ssdcableslay5pconwater[1]->SetLineColor(7);
7605 ////////////////////////////////////
7606 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7608 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7609 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7610 + fgkSSDCablesLay5RightSideWaterHeight;
7611 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7612 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7613 + fgkSSDCablesLay5RightSideWaterHeight;
7614 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7615 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7616 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7617 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7618 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7619 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7620 ssdcableslay5pconwater[2]->SetLineColor(7);
7621 ////////////////////////////////////
7622 TGeoRotation* ssdcableslay5pconwaterot[4];
7623 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7624 for(Int_t i=0; i<4; i++){
7625 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7626 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7627 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7628 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7629 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7630 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7631 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7632 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7634 /////////////////////////
7635 // SSD Layer 6 Cables
7636 /////////////////////////
7637 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+fgkSSDCablesLay6TubeRadiusMin;
7638 Double_t ssdcablelay6rightsidelength = 2.*ssdcablelay5rightsidelength;
7639 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+fgkSSDCablesLay6RightSideHeight;
7640 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7641 ssdcableslay6rightsideradiusmax,
7642 0.5*ssdcablelay6rightsidelength);
7643 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7644 ssdcablelay6rightubeshape,
7646 ssdcablelay6righttube->SetLineColor(9);
7647 TGeoTranslation* ssdcablelay6rightrans =
7648 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7649 + fgkEndCapSupportCenterLay6Position
7650 + 0.5*ssdcablelay6rightsidelength);
7651 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7652 - 0.5*ssdcablelay6rightsidelength
7653 - fgkEndCapSupportCenterLay6Position
7654 - fgkEndCapSupportCenterLay6ITSPosition);
7655 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7656 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7657 ////////////////////////////////////
7658 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7659 ////////////////////////////////////
7660 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7662 TGeoVolume* ssdcableslay6pcon;
7663 Double_t ssdcableslay6pconrmin[2];
7664 Double_t ssdcableslay6pconrmax[2];
7665 Double_t ssdcableslay6pconzsection[2];
7666 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7667 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7668 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7669 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7670 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7671 + fgkEndCapSupportCenterLay6Position
7672 + ssdcablelay6rightsidelength;
7673 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7674 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7675 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7676 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7677 ssdcableslay6pconshape,fSSDCopper);
7678 ssdcableslay6pcon->SetLineColor(9);
7679 for(Int_t i=0; i<4; i++){
7680 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7681 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7683 ////////////////////////////////////
7684 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7685 /////////////////////////
7686 // Water Tubes Layer 6
7687 /////////////////////////
7688 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7689 ssdcableslay6rightsideradiusmax
7690 + fgkSSDCablesLay5RightSideWaterHeight,
7691 0.5*ssdcablelay6rightsidelength);
7692 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7693 ssdcablelay6righwatertubeshape,
7694 fSSDCoolingTubeWater);
7695 ssdcablelay6rightwatertube->SetLineColor(7);
7696 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7697 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7698 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7700 TGeoVolume* ssdcableslay6waterpcon;
7701 Double_t ssdcableslay6waterpconrmin[2];
7702 Double_t ssdcableslay6waterpconrmax[2];
7703 Double_t ssdcableslay6waterpconzsection[2];
7704 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7705 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7706 + fgkSSDCablesLay5RightSideWaterHeight;
7707 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7708 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7709 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7710 + fgkEndCapSupportCenterLay6Position
7711 + ssdcablelay6rightsidelength;
7712 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7713 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7714 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7715 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7716 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7717 ssdcableslay6waterpcon->SetLineColor(7);
7718 TGeoRotation* ssdcableslay6pconwaterot[4];
7719 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7720 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7721 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7722 for(Int_t i=0; i<4; i++){
7723 ssdcableslay6pconwaterot[i] = new TGeoRotation();
7724 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7725 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7726 * (*ssdcableslay6pconwaterot[i]));
7727 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7728 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7730 ////////////////////////////////////////
7731 // From ITS Ring to Patch Panel3-RB26
7732 ////////////////////////////////////////
7733 Double_t ssdcablepatchpanel3BB26radiusmin[2];
7734 Double_t ssdcablepatchpanel3BB26radiusmax[2];
7735 Double_t ssdcablepatchpanel3RB26zsection[2];
7736 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8;
7737 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
7738 + fgkSSDCablesLay5RightSideHeight
7739 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
7740 ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
7741 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
7742 + 0.*fgkSSDCablesLay5RightSideHeight
7743 + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
7744 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
7745 + fgkSSDCentralAL3SupportLength
7746 + fgkSSDPConeZLength[0];
7747 ssdcablepatchpanel3RB26zsection[1] = fgkSSDPatchPanel2RB26ITSDistance;
7748 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
7749 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7750 - 0.5*ssdcableangle,ssdcableangle,2);
7751 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7752 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7753 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7754 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7755 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
7756 TGeoRotation* ssdcablepatchpanel3B26rot[4];
7757 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
7758 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
7759 ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
7760 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7761 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
7762 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0]
7763 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7764 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
7765 ////////////////////////////////////
7766 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7767 ////////////////////////////////////////
7768 // ITS Ring Cables RB26 Part
7769 ////////////////////////////////////////
7770 Double_t ssdcableitsring3BB26pconzsection[2];
7771 Double_t ssdcableitsring3BB26pconrmin[2];
7772 Double_t ssdcableitsring3BB26pconrmax[2];
7773 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7774 + fgkSSDCentralAL3SupportLength
7775 + (4.0/5.0)*fgkSSDPConeZLength[0];
7776 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
7777 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
7778 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
7779 + fgkSSDCablesLay5RightSideHeight
7780 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
7781 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7782 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7783 TGeoPcon* ssdcableitsring3BB26pconshape[4];
7784 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7785 - 0.5*ssdcableangle,ssdcableangle
7786 + (fgkSSDCablesPatchPanel2RB26Angle[0]
7787 - fgkSSDCableAngle),2);
7788 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7789 - 0.5*ssdcableangle,ssdcableangle
7790 + 3.0*fgkSSDCableAngle
7791 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7792 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-fgkSSDCablesPatchPanel2RB26Angle[0]
7793 - 0.5*ssdcableangle,ssdcableangle
7795 + fgkSSDCablesPatchPanel2RB26Angle[0],2);
7796 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7797 - 0.5*ssdcableangle,ssdcableangle
7798 + 3.0*fgkSSDCableAngle
7799 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7800 for(Int_t i=0;i<4;i++)
7801 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7802 ssdcableitsring3BB26pconrmin[j],
7803 ssdcableitsring3BB26pconrmax[j]);
7804 TGeoVolume* ssdcableitsring3BB26pcon[4];
7805 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7806 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7807 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7808 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7809 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7810 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7811 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7812 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7813 for(Int_t i=0;i<4;i++){
7814 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
7815 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
7817 ////////////////////////////////////
7818 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7819 // + ssdcableitsring3BB26pconshape[1]->Capacity()
7820 // + ssdcableitsring3BB26pconshape[2]->Capacity()
7821 // + ssdcableitsring3BB26pconshape[3]->Capacity();
7822 ////////////////////////////////////////
7823 // From ITS Ring to Patch Panel2-RB24
7824 ////////////////////////////////////////
7825 Double_t ssdcablepatchpanel3BB24radiusmin[2];
7826 Double_t ssdcablepatchpanel3BB24radiusmax[2];
7827 Double_t ssdcablepatchpanel3RB24zsection[2];
7828 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7829 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
7830 ssdcablepatchpanel3BB24radiusmin[1] = fgkSSDPatchPanel2RB24Radius;
7831 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
7832 + 0.*fgkSSDCablesLay5RightSideHeight
7833 + 0.*fgkSSDCablesLay6RightSideHeight
7834 + 0.5*fgkSSDPatchPanelHeight;
7835 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7836 - fgkSSDCentralAL3SupportLength
7837 - fgkSSDPConeZLength[0];
7838 ssdcablepatchpanel3RB24zsection[1] = -fgkSSDPatchPanel2RB24ITSDistance;
7839 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
7840 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7841 - 0.5*ssdcableangle,ssdcableangle,2);
7842 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7843 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7844 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7845 ssdcablepatchpanel3RB24pconshape,
7847 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
7848 TGeoRotation* ssdcablepatchpanel3B24rot[4];
7849 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
7850 ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
7851 ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0]
7852 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7853 ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
7854 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0]
7855 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7856 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
7857 ////////////////////////////////////
7858 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7859 ////////////////////////////////////////
7860 // ITS Ring Cables RB24 Part
7861 ////////////////////////////////////////
7862 Double_t ssdcableitsring3BB24pconzsection[2];
7863 Double_t ssdcableitsring3BB24pconrmin[2];
7864 Double_t ssdcableitsring3BB24pconrmax[2];
7865 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7866 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
7867 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
7868 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
7869 + fgkSSDCablesLay5RightSideHeight
7870 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
7871 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
7872 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
7873 TGeoPcon* ssdcableitsring3BB24pconshape[4];
7874 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7875 + (90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7876 - fgkSSDCableAngle),2);
7877 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+fgkSSDCableAngle-0.5*ssdcableangle,
7878 ssdcableangle-fgkSSDCableAngle
7879 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
7880 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7882 + 90.0-fgkSSDCablesPatchPanel2RB24Angle[1],2);
7883 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+fgkSSDCableAngle-0.5*ssdcableangle,
7884 ssdcableangle-fgkSSDCableAngle
7885 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
7886 for(Int_t i=0;i<4;i++)
7887 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
7888 ssdcableitsring3BB24pconrmin[j],
7889 ssdcableitsring3BB24pconrmax[j]);
7890 TGeoVolume* ssdcableitsring3BB24pcon[4];
7891 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
7892 ssdcableitsring3BB24pconshape[0],fSSDCopper);
7893 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
7894 ssdcableitsring3BB24pconshape[1],fSSDCopper);
7895 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
7896 ssdcableitsring3BB24pconshape[2],fSSDCopper);
7897 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
7898 ssdcableitsring3BB24pconshape[3],fSSDCopper);
7899 for(Int_t i=0;i<4;i++){
7900 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
7901 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
7903 ////////////////////////////////////
7904 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
7905 // + ssdcableitsring3BB24pconshape[1]->Capacity()
7906 // + ssdcableitsring3BB24pconshape[2]->Capacity()
7907 // + ssdcableitsring3BB24pconshape[3]->Capacity();
7908 ////////////////////////////////////
7909 // Volumes for Material Budget
7910 ////////////////////////////////////
7911 TGeoTube* ssdcablelay6materialbudgetubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax
7912 + fgkSSDCablesLay5RightSideWaterHeight,
7913 ssdcableslay6rightsideradiusmax
7914 + fgkSSDCablesLay5RightSideWaterHeight
7915 + fgkSSDCableMaterialBudgetHeight,0.5*ssdcablelay6rightsidelength);
7916 TGeoVolume* ssdcablelay6materialbudgetube = new TGeoVolume("SSDCableLay6MaterialBudgetTube",
7917 ssdcablelay6materialbudgetubeshape,
7919 ssdcablelay6materialbudgetube->SetLineColor(9);
7920 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,1,ssdcablelay6rightrans);
7921 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,2,ssdcablesLay6RightTubeToLeftrans);
7923 TGeoPcon* ssdcablelay6materialbudgetpconshape =
7924 new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
7925 TGeoVolume* ssdcablelay6materialbudgetpcon;
7926 Double_t ssdcablelay6materialbudgetpconrmin[2];
7927 Double_t ssdcablelay6materialbudgetpconrmax[2];
7928 Double_t ssdcablelay6materialbudgetpconzsection[2];
7929 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
7930 + fgkSSDCablesLay5RightSideWaterHeight;
7931 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
7932 + fgkSSDCableMaterialBudgetHeight;
7933 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
7934 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
7935 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7936 + fgkEndCapSupportCenterLay6Position
7937 + ssdcablelay6rightsidelength;
7938 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7939 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
7940 ssdcablelay6materialbudgetpconzsection[i],
7941 ssdcablelay6materialbudgetpconrmin[i],
7942 ssdcablelay6materialbudgetpconrmax[i]);
7943 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
7944 ssdcablelay6materialbudgetpconshape,fSSDCopper);
7945 ssdcablelay6materialbudgetpcon->SetLineColor(9);
7946 for(Int_t i=0; i<4; i++){
7947 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
7948 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7950 ////////////////////////////////////
7951 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
7952 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
7953 Double_t ssdcablesvolume = 0.0;
7954 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
7955 std::cout << ssdcablesvolume << std::endl;*/
7956 return ssdcablesmother;
7958 ////////////////////////////////////////////////////////////////////////////////
7959 TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
7960 Double_t height, const char* shapename, Int_t isign) const{
7961 /////////////////////////////////////////////////////////////
7962 // Method generating an Arb shape
7963 /////////////////////////////////////////////////////////////
7964 const Int_t kvertexnumber = 8;
7965 const Int_t ktransvectnumber = 2;
7966 TVector3 vertex[kvertexnumber];
7967 TVector3 transvector[2];
7968 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
7969 /////////////////////////////////////////////////////////////
7970 //Setting the vertices for TGeoArb8
7971 /////////////////////////////////////////////////////////////
7972 vertex[0] = *vertexpos[0];
7973 vertex[1] = *vertexpos[1];
7974 vertex[2] = vertex[1];
7975 vertex[3] = vertex[0];
7976 vertex[4] = *vertexpos[2];
7977 vertex[5] = *vertexpos[3];
7978 vertex[6] = vertex[5];
7979 vertex[7] = vertex[4];
7981 // NB: order of points is clockwise
7983 vertex[2] -= transvector[0];
7984 vertex[3] -= transvector[0];
7985 vertex[6] -= transvector[1];
7986 vertex[7] -= transvector[1];
7989 vertex[0] += transvector[0];
7990 vertex[1] += transvector[0];
7991 vertex[4] += transvector[1];
7992 vertex[5] += transvector[1];
7995 /////////////////////////////////////////////////////////////
7996 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
7997 for(Int_t i = 0; i<kvertexnumber;i++) {
7998 arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
8003 ///////////////////////////////////////////////////////////////////////////////
8004 TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8005 Double_t rmax, Int_t nedges, Double_t height){
8006 /////////////////////////////////////////////////////////////
8007 // Method generating Arc shape
8008 /////////////////////////////////////////////////////////////
8009 const Int_t kvertexnumber = 2*nedges+2;
8010 TGeoXtru* arcshape = new TGeoXtru(2);
8011 TVector3** vertexposition[2];
8012 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8013 Double_t angle = 0.;
8014 for(Int_t i=0; i<nedges+1; i++){
8015 angle = 90.+0.5*phi-i*(phi/nedges);
8016 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
8017 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
8019 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8020 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8021 for(Int_t i=0; i<kvertexnumber; i++){
8022 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8023 yvertexpoints[i] = vertexposition[0][i]->Y();
8025 else if(i>=1&&i<nedges+2)
8027 xvertexpoints[i] = vertexposition[1][i-1]->X();
8028 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8032 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8033 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8036 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8037 arcshape->DefineSection(0,-0.5*height);
8038 arcshape->DefineSection(1,0.5*height);
8039 /////////////////////////////////////////////////////////////
8040 // Deallocating memory
8041 /////////////////////////////////////////////////////////////
8042 for(Int_t i=0; i<2; i++){
8043 for(Int_t j=0; j<nedges+1; j++)
8044 delete vertexposition[i][j];
8045 delete [] vertexposition[i];
8047 delete [] xvertexpoints;
8048 delete [] yvertexpoints;
8049 /////////////////////////////////////////////////////////////
8052 ////////////////////////////////////////////////////////////////////////////////
8053 TGeoShape* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
8054 ///////////////////////////////////////////////////////////////////////
8055 // Method Generating the Screw Shape
8056 // radius[0]: outer radius
8057 // radius[1]: inner radius
8058 // edgesnumber[0]: outer number of edges
8059 // edgesnumber[1]: inner number of edges
8060 // section[0]: lower section position
8061 // section[1]: higher section position
8062 ///////////////////////////////////////////////////////////////////////
8063 Double_t outradius = radius[0];
8064 Double_t inradius = radius[1];
8065 Int_t outvertexnumber = edgesnumber[0];
8066 Int_t invertexnumber = edgesnumber[1];
8067 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8068 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8069 for(Int_t i=0; i<outvertexnumber; i++){
8070 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8071 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8073 for(Int_t i=0; i<invertexnumber; i++){
8074 xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8075 yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
8077 TGeoXtru* screwshapeout = new TGeoXtru(2);
8078 screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8079 screwshapeout->DefineSection(0,section[0]);
8080 screwshapeout->DefineSection(1,section[1]);
8081 TGeoXtru* screwshapein = new TGeoXtru(2);
8082 screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8083 screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8084 screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8085 TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8086 TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8088 delete [] xscrewvertex;
8089 delete [] yscrewvertex;
8092 ////////////////////////////////////////////////////////////////////////////////
8093 TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
8094 ///////////////////////////////////////////////////////////////////////
8095 // Method Generating the Hole Shape
8096 // radius of the Hole
8097 // nedges: number of edges to approximate the circle
8098 ///////////////////////////////////////////////////////////////////////
8099 Double_t* xholevertex = new Double_t[nedges];
8100 Double_t* yholevertex = new Double_t[nedges];
8101 Double_t z = 0.5*(section[0]+section[1]);
8102 Double_t dz = 0.5*(section[1]-section[0]);
8103 TGeoTranslation *tr = 0;
8104 if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8105 tr = new TGeoTranslation(0.,0.,z);
8106 tr->RegisterYourself();
8108 TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8109 for(Int_t i=0; i<nedges; i++){
8110 xholevertex[i] = radius*CosD(i*360./nedges);
8111 yholevertex[i] = radius*SinD(i*360./nedges);
8113 TGeoXtru* holeshapeout = new TGeoXtru(2);
8114 holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8115 holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8116 holeshapeout->DefineSection(1,section[1]+0.01);
8117 TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8118 TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8120 delete [] xholevertex;
8121 delete [] yholevertex;
8124 ////////////////////////////////////////////////////////////////////////////////
8125 TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
8126 /////////////////////////////////////////////////////////////
8127 // Given an axis specified by param, it gives the reflection of the point
8128 // respect to the axis
8129 /////////////////////////////////////////////////////////////
8130 TVector3* n = new TVector3(param[0],param[1],param[2]);
8131 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8132 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
8133 /////////////////////////////////////////////////////////////
8134 // Deallocating memory
8135 /////////////////////////////////////////////////////////////
8137 /////////////////////////////////////////////////////////////
8138 return reflectedvector;
8140 ////////////////////////////////////////////////////////////////////////////////
8141 TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
8145 /////////////////////////////////////////////////////////////
8146 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
8147 /////////////////////////////////////////////////////////////
8148 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8149 const Double_t *vect = hmatrix->GetTranslation();
8150 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
8151 hmatrix->SetTranslation(newvect);
8152 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8156 ////////////////////////////////////////////////////////////////////////////////
8157 TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
8158 /////////////////////////////////////////////////////////////
8159 // Method returning the Medium type
8160 /////////////////////////////////////////////////////////////
8162 sprintf(ch, "ITS_%s",mediumName);
8163 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8165 AliError(Form("medium %s not found !\n", mediumName));
8168 ////////////////////////////////////////////////////////////////////////////////
8169 void AliITSv11GeometrySSD::CreateMaterials(){
8170 ///////////////////////////////////
8171 // This part has to be modified
8172 ///////////////////////////////////
8173 ///////////////////////////////////
8174 // Silicon for Sensor
8175 ///////////////////////////////////
8176 fSSDSensorMedium = GetMedium("SI$");
8177 ///////////////////////////////////
8178 // Silicon Mixture for Sensor
8179 ///////////////////////////////////
8180 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8181 fSSDChipGlueMedium = GetMedium("EPOXY$");
8182 ///////////////////////////////////
8183 // Stiffener Components Materials
8184 ///////////////////////////////////
8185 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
8186 ///////////////////////////
8187 // Stiffener Connectors
8188 ///////////////////////////
8189 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
8190 ////////////////////////////////
8191 // Stiffener 0603-1812 Capacitor
8192 ////////////////////////////////
8193 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8194 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8195 fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$");
8196 ///////////////////////////
8197 // Stiffener Hybrid Wire
8198 ///////////////////////////
8199 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
8200 ///////////////////////////
8201 // Al for Cooling Block
8202 ///////////////////////////
8203 fSSDAlCoolBlockMedium = GetMedium("AL$");
8204 //////////////////////////////////////////////////////
8205 // Kapton and Al for Chip Cable Flex and Ladder Cables
8206 //////////////////////////////////////////////////////
8207 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8208 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8209 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8210 fSSDAlTraceFlexMedium = GetMedium("AL$");
8211 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8212 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
8213 /////////////////////////////////////////////////////////////////
8214 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8215 //////////////////////////////////////////////////////////////////
8216 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
8217 /////////////////////////////////////////////////////////////////
8218 // G10 for Detector Leg, TubeHolder
8219 //////////////////////////////////////////////////////////////////
8220 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8221 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8222 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8223 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8224 /////////////////////////////////////////////////////////////////
8225 // Water and Phynox for Cooling Tube
8226 //////////////////////////////////////////////////////////////////
8227 fSSDCoolingTubeWater = GetMedium("WATER$");
8228 fSSDCoolingTubePhynox = GetMedium("INOX$");
8229 /////////////////////////////////////////////////////////////////////
8230 // Material for Support Rings
8231 /////////////////////////////////////////////////////////////////////
8232 fSSDSupportRingAl = GetMedium("AL$");
8233 fSSDRohaCellCone = GetMedium("ROHACELL$");
8234 /////////////////////////////////////////////////////////////////////
8235 fSSDAir = GetMedium("SDD AIR$");
8236 fSSDCopper = GetMedium("COPPER$");
8237 fSSDSn = GetMedium("Sn$");
8238 fCreateMaterials = kTRUE;
8240 /////////////////////////////////////////////////////////////////////