]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - ITS/AliITSv11GeometrySSD.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
for non-miscalibrated digits, set an ad-hoc conversion factor fAdC->fToT to have...
[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySSD.cxx
... / ...
CommitLineData
1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16
17//*************************************************************************
18// SSD geometry, based on ROOT geometrical modeler
19//
20// Enrico Cattaruzza ecattar@ts.infn.it
21//*************************************************************************
22#include "TMath.h"
23#include "TGeoVolume.h"
24#include "TGeoMatrix.h"
25#include <TGeoManager.h>
26#include "TVector3.h"
27#include "TGeoArb8.h"
28#include "TList.h"
29#include "TGeoMatrix.h"
30#include "TGeoCompositeShape.h"
31#include "TGeoTube.h"
32#include "TGeoBBox.h"
33#include "AliITSv11GeometrySSD.h"
34/////////////////////////////////////////////////////////////////////////////////
35//Parameters for SSD Geometry
36/////////////////////////////////////////////////////////////////////////////////
37// Layer5 (lengths are in mm and angles in degrees)
38/////////////////////////////////////////////////////////////////////////////////
39const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
40const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
41const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
42const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
43const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
44const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
45/////////////////////////////////////////////////////////////////////////////////
46// Layer6 (lengths are in mm and angles in degrees)
47/////////////////////////////////////////////////////////////////////////////////
48const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
49const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
50const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
51const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
52const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
53const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
54/////////////////////////////////////////////////////////////////////////////////
55// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
56/////////////////////////////////////////////////////////////////////////////////
57const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
58const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
59const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
60const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
61const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
62const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
63const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
64const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
65/////////////////////////////////////////////////////////////////////////////////
66// Stiffener (lengths are in mm and angles in degrees)
67/////////////////////////////////////////////////////////////////////////////////
68const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
69const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
70const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm;
71const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
72const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
73const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
74const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
75const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
76const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
77const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 1.400*fgkmm;
78const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
79const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
80const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] = {44.32*fgkmm,
81 0.33*fgkmm};
82const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
83const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
84const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
85const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight =
86 0.25*fgkSSDStiffenerHeight;
87/////////////////////////////////////////////////////////////////////////////////
88// Cooling Block (lengths are in mm and angles in degrees)
89/////////////////////////////////////////////////////////////////////////////////
90const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
91const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
92const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
93 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
94const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
95 {1.000*fgkmm, 0.120*fgkmm};
96const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
97 {1.900*fgkmm, 0.400*fgkmm};
98const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
99 1.500*fgkmm;
100const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
101 0.300*fgkmm;
102/////////////////////////////////////////////////////////////////////////////////
103// SSD Sensor (lengths are in mm and angles in degrees)
104/////////////////////////////////////////////////////////////////////////////////
105const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
106 "SSDSensorSensitiveVol";
107const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
108const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
109const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
110const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
111 fgkSSDSensorLength-39.1*fgkmm;
112const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
113const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
114/////////////////////////////////////////////////////////////////////////////////
115// Flex (lengths are in mm and angles in degrees)
116/////////////////////////////////////////////////////////////////////////////////
117const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
118const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
119 {0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
120 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
121 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
122 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)-4.000*fgkmm,
123 9.500*fgkmm, 10.000*fgkmm};
124const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
125 { 9.340*fgkmm, 5.380*fgkmm};
126const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
127 { 0.030*fgkmm, 0.020*fgkmm};
128const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
129const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
130const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
131const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
132 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
133const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
134 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
135/////////////////////////////////////////////////////////////////////////////////
136// SSD Ladder Cable (lengths are in mm and angles in degrees)
137/////////////////////////////////////////////////////////////////////////////////
138const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
139/////////////////////////////////////////////////////////////////////////////////
140// SSD Module (lengths are in mm and angles in degrees)
141/////////////////////////////////////////////////////////////////////////////////
142const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
143 { 1.000*fgkmm, 3.900*fgkmm};
144const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
145 45.600*fgkmm;
146const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
147 5.075*fgkmm;
148/////////////////////////////////////////////////////////////////////////////////
149// Sensor Support (lengths are in mm and angles in degrees)
150/////////////////////////////////////////////////////////////////////////////////
151const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
152 5.800*fgkmm;
153const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
154 2.000*fgkmm;
155const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
156 { 4.620*fgkmm, 5.180*fgkmm};
157const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
158 { 0.450*fgkmm, 0.450*fgkmm};
159const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition =
160 0.5*(fgkSSDModuleSensorSupportDistance
161 + fgkSSDSensorSideSupportThickness[0])
162 - fgkSSDSensorSideSupportLength;
163const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
164 5.250*fgkmm;
165const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
166 1.680*fgkmm;
167const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2] =
168 {fgkSSDSensorSideSupportHeight[0]+fgkSSDSensorSideSupportThickness[0],
169 fgkSSDSensorSideSupportHeight[1]+fgkSSDSensorSideSupportThickness[1]};
170const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2] =
171 {fgkSSDSensorSideSupportThickness[0],fgkSSDSensorSideSupportThickness[1]};
172const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
173 19.000*fgkmm;
174/////////////////////////////////////////////////////////////////////////////////
175// Chip Cables (lengths are in mm and angles in degrees)
176/////////////////////////////////////////////////////////////////////////////////
177const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
178 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
179const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
180 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
181 - (fgkSSDSensorSideSupportHeight[1]-fgkSSDSensorSideSupportHeight[0])
182 - fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
183 - fgkSSDChipHeight-fgkSSDSensorHeight,
184 fgkSSDModuleCoolingBlockToSensor
185 - fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
186 - fgkSSDChipHeight-fgkSSDSensorHeight};
187const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
188 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
189/////////////////////////////////////////////////////////////////////////////////
190// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
191/////////////////////////////////////////////////////////////////////////////////
192const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
193 3.820*fgkmm;
194const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
195 fgkSSDSensorLength-fgkSSDSensorOverlap;
196const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
197 { 0.86*fgkmm, 0.30*fgkmm};
198const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
199 { 30.00, 90.00};
200const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
201 1.78*fgkmm;
202/////////////////////////////////////////////////////////////////////////////////
203//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
204/////////////////////////////////////////////////////////////////////////////////
205const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength =
206 fgkSSDModuleSensorSupportDistance-2.*fgkCarbonFiberJunctionToSensorSupport;
207const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle =
208 60.00;
209const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
210 { 0.751*fgkmm, 0.482*fgkmm};
211const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
212 1.630*fgkmm;
213const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth =
214 0.950*fgkmm;
215const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength =
216 fgkCarbonFiberTriangleLength-0.5*fgkCarbonFiberSupportTopEdgeDist[1]
217 / TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad());
218const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength =
219 0.5*(fgkCarbonFiberJunctionWidth-fgkCarbonFiberSupportWidth)
220 - fgkCarbonFiberSupportTopEdgeDist[0]-fgkCarbonFiberSupportWidth;
221/////////////////////////////////////////////////////////////////////////////////
222// Carbon Fiber Lower Support Parameters (lengths are in mm)
223/////////////////////////////////////////////////////////////////////////////////
224const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
225 = 0.950*fgkmm;
226const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
227 = 1.600*fgkmm;
228const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
229 = 0.830*fgkmm;
230const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
231 = 0.5*fgkCarbonFiberSupportWidth;
232const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
233 = fgkCarbonFiberJunctionWidth
234 - 2.*(fgkCarbonFiberLowerSupportWidth
235 + fgkCarbonFiberLowerSupportVolumeSeparation);
236const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
237 = {fgkCarbonFiberLowerSupportWidth
238 + fgkCarbonFiberLowerSupportVolumeSeparation,
239 fgkCarbonFiberLowerSupportWidth
240 + fgkCarbonFiberLowerSupportVolumeSeparation
241 + fgkCarbonFiberLowerSupportTransverseWidth};
242/////////////////////////////////////////////////////////////////////////////////
243// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
244/////////////////////////////////////////////////////////////////////////////////
245const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
246 {0.5*(fgkSSDLay5LadderLength
247 -fgkSSDLay5SensorsNumber*fgkCarbonFiberJunctionWidth
248 -fgkCarbonFiberLowerSupportWidth),
249 0.5*(fgkSSDLay5LadderLength
250 -fgkSSDLay5SensorsNumber*fgkCarbonFiberJunctionWidth
251 +fgkCarbonFiberLowerSupportWidth)};
252const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
253 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
254 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
255const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
256 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
257 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
258/////////////////////////////////////////////////////////////////////////////////
259// Cooling Tube Support (lengths are in mm and angles in degrees)
260/////////////////////////////////////////////////////////////////////////////////
261const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
262const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
263 = fgkSSDCoolingBlockHoleRadius[0];
264const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
265const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
266const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
267const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
268 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
269const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber = 11.70*fgkmm;
270/////////////////////////////////////////////////////////////////////////////////
271// Cooling Tube (lengths are in mm and angles in degrees)
272/////////////////////////////////////////////////////////////////////////////////
273const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax =
274 fgkCoolingTubeSupportRmin;
275const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm;
276const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
277 fgkCarbonFiberJunctionWidth;
278const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
279 fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength;
280/////////////////////////////////////////////////////////////////////////////////
281// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
282/////////////////////////////////////////////////////////////////////////////////
283const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
284 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
285const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
286 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
287const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
288 20.0*fgkmm;
289const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
290 40.0;
291const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
292 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
293const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
294 2.5*fgkmm;
295const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
296 { 56.0*fgkmm, 12.0*fgkmm};
297const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
298 { 5.0*fgkmm, 2.9*fgkmm};
299const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
300 1.0*fgkmm;
301const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
302 6.0*fgkmm;
303const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth =
304 4.0*fgkmm;
305const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
306 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
307/////////////////////////////////////////////////////////////////////////////////
308ClassImp(AliITSv11GeometrySSD)
309/////////////////////////////////////////////////////////////////////////////////
310AliITSv11GeometrySSD::AliITSv11GeometrySSD():
311 AliITSv11Geometry(),
312 fSSDChipMedium(),
313 fSSDChipGlueMedium(),
314 fSSDStiffenerMedium(),
315 fSSDStiffenerConnectorMedium(),
316 fSSDStiffener0603CapacitorMedium(),
317 fSSDStiffener1812CapacitorMedium(),
318 fSSDStiffenerHybridWireMedium(),
319 fSSDKaptonFlexMedium(),
320 fSSDAlTraceFlexMedium(),
321 fSSDAlTraceLadderCableMedium(),
322 fSSDKaptonLadderCableMedium(),
323 fSSDKaptonChipCableMedium(),
324 fSSDAlTraceChipCableMedium(),
325 fSSDAlCoolBlockMedium(),
326 fSSDSensorMedium(),
327 fSSDSensorSupportMedium(),
328 fSSDCarbonFiberMedium(),
329 fSSDTubeHolderMedium(),
330 fSSDCoolingTubeWater(),
331 fSSDCoolingTubePhynox(),
332 fSSDMountingBlockMedium(),
333 fMotherVol(0),
334 fColorCarbonFiber(4),
335 fColorRyton(5),
336 fColorPhynox(5),
337 fColorSilicon(3),
338 fColorAl(7),
339 fColorKapton(6),
340 fColorPolyhamide(5),
341 fColorStiffener(9),
342 fColorEpoxy(30)
343{
344 ////////////////////////
345 // Standard constructor
346 ////////////////////////
347 CreateMaterials();
348}
349/////////////////////////////////////////////////////////////////////////////////
350AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
351 AliITSv11Geometry(s.GetDebug()),
352 fSSDChipMedium(s.fSSDChipMedium),
353 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
354 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
355 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
356 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
357 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
358 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
359 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
360 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
361 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
362 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
363 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
364 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
365 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
366 fSSDSensorMedium(s.fSSDSensorMedium),
367 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
368 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
369 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
370 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
371 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
372 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
373 fMotherVol(s.fMotherVol),
374 fColorCarbonFiber(s.fColorCarbonFiber),
375 fColorRyton(s.fColorRyton),
376 fColorPhynox(s.fColorPhynox),
377 fColorSilicon(s.fColorSilicon),
378 fColorAl(s.fColorAl),
379 fColorKapton(s.fColorKapton),
380 fColorPolyhamide(s.fColorPolyhamide),
381 fColorStiffener(s.fColorStiffener),
382 fColorEpoxy(s.fColorEpoxy)
383{
384 ////////////////////////
385 // Copy Constructor
386 ////////////////////////
387 CreateMaterials();
388}
389/////////////////////////////////////////////////////////////////////////////////
390AliITSv11GeometrySSD& AliITSv11GeometrySSD::
391operator=(const AliITSv11GeometrySSD &s){
392 ////////////////////////
393 // Assignment operator
394 ////////////////////////
395 this->~AliITSv11GeometrySSD();
396 new(this) AliITSv11GeometrySSD(s);
397 return *this;
398/*
399 if(&s == this) return *this;
400 fMotherVol = s.fMotherVol;
401 return *this;
402 */
403}
404/////////////////////////////////////////////////////////////////////////////////
405// Setting the transformation Matrices
406/////////////////////////////////////////////////////////////////////////////////
407void AliITSv11GeometrySSD::SetSSDSensorSupportCombiTransMatrix(){
408 /////////////////////////////////////////////////////////////
409 // Method generating CombiTrans Matrix for SSD Sensor Support
410 /////////////////////////////////////////////////////////////
411 //Translation Parameters SSDSensorSupportAssembly:
412 ////////////////////////////////////////////////////////
413 const Double_t kssdsensorsupporttransx[3] = {-0.5*fgkSSDSensorSideSupportWidth,
414 0.5*fgkSSDSensorSideSupportWidth,
415 0.5*fgkSSDSensorCenterSupportThickness[0]
416 - fgkSSDSensorCenterSupportPosition};
417 const Double_t kssdsensorsupporttransy[3] =
418 {0.5*fgkSSDSensorSideSupportThickness[0],
419 -0.5*fgkSSDSensorSideSupportThickness[0]
420 -fgkSSDModuleSensorSupportDistance,
421 0.5*fgkSSDSensorCenterSupportWidth
422 -0.5*fgkSSDModuleSensorSupportDistance};
423 const Double_t kssdsensorsupporttransz[3] = {0.,0.,
424 fgkSSDSensorCenterSupportThickness[0]};
425 ////////////////////////////////////////////////////////
426 //Rotational Parameters SSDSensorSupportAssembly:
427 ////////////////////////////////////////////////////////
428 const Double_t kssdsensorsupportrotphi[3] = { 0., 180., 270.};
429 const Double_t kssdsensorsupportrottheta[3] = { 90., 90., 90.};
430 const Double_t kssdsensorsupportrotpsi[3] = {- 90.,- 90.,- 90.};
431 ////////////////////////////////////////////////////////////////
432 //Name of CombiTrans Transformation of SSDSensorSupportAssembly:
433 ////////////////////////////////////////////////////////////////
434 char ssdsensorsupportcombitransname[40];
435 char ssdsensorsupportrotname[40];
436 TGeoCombiTrans *ssdsensorsupportlocalmatrix[fgkSSDSensorSupportCombiTransNumber];
437 for(Int_t i=0; i<fgkSSDSensorSupportCombiTransNumber; i++){
438 sprintf(ssdsensorsupportcombitransname,"SSDSensorSupportCombiTrans%i",i);
439 sprintf(ssdsensorsupportrotname,"SSDSensorSupportRot%i",i);
440 ssdsensorsupportlocalmatrix[i] =
441 new TGeoCombiTrans(ssdsensorsupportcombitransname,
442 kssdsensorsupporttransx[i],
443 kssdsensorsupporttransy[i],
444 kssdsensorsupporttransz[i],
445 new TGeoRotation(ssdsensorsupportrotname,
446 kssdsensorsupportrotphi[i],
447 kssdsensorsupportrottheta[i],
448 kssdsensorsupportrotpsi[i]));
449 fSSDSensorSupportCombiTransMatrix[i] = ssdsensorsupportlocalmatrix[i];
450 }
451}
452/////////////////////////////////////////////////////////////////////////////////
453void AliITSv11GeometrySSD::SetSSDModuleCombiTransMatrix(Double_t SSDChipCablesHeigth){
454 /////////////////////////////////////////////////////////////
455 // Method generating CombiTrans Matrix for SSD Module
456 /////////////////////////////////////////////////////////////
457 //Translation Parameters SSDModuleAssembly:
458 ////////////////////////////////////////////////////////
459 const Double_t kssdmoduletransx[7] = {0.5*fgkSSDStiffenerLength,
460 0.5*fgkSSDChipLength+0.5*(fgkSSDStiffenerLength
461 - (fgkSSDChipNumber*fgkSSDChipLength+(fgkSSDChipNumber-1)
462 * fgkSSDChipSeparationLength)),
463 - fgkSSDModuleStiffenerPosition[0]+0.5*fgkSSDSensorWidth,
464 0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
465 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
466 0.5*fgkSSDStiffenerLength-0.5*fgkSSDModuleSensorSupportDistance
467 - fgkSSDCoolingBlockLength,
468 0.5*(fgkSSDStiffenerLength+fgkSSDChipCablesLength[1]
469 + (fgkSSDChipNumber-1)*fgkSSDChipCablesLength[0]),
470 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
471 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)};
472 const Double_t kssdmoduletransy[7] = {0.5*fgkSSDStiffenerWidth,
473 0.5*fgkSSDChipWidth+(fgkSSDStiffenerWidth
474 - fgkSSDStiffenerToChipDist-fgkSSDChipWidth),
475 - fgkSSDModuleStiffenerPosition[1]+0.5*fgkSSDSensorLength,
476 fgkSSDStiffenerWidth,
477 0.,
478 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
479 - fgkSSDStiffenerWidth
480 + fgkSSDStiffenerToChipDist+fgkSSDChipWidth,
481 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
482 - fgkSSDStiffenerWidth};
483 const Double_t kssdmoduletransz[7] = {0.5*fgkSSDStiffenerHeight,
484 - 0.5*fgkSSDChipHeight,
485 0.5*fgkSSDSensorHeight-fgkSSDStiffenerHeight-fgkSSDChipHeight
486 - SSDChipCablesHeigth,
487 - 0.5*fgkSSDFlexHeight[0],
488 fgkSSDStiffenerHeight,
489 - fgkSSDChipHeight,
490 - 0.5*fgkSSDChipHeight};
491 ////////////////////////////////////////////////////////
492 //Rotational Parameters SSDModuleAssembly:
493 ////////////////////////////////////////////////////////
494 const Double_t kssdmodulerotphi[7] = { 0., 0., 90., 0., 0., 90., 180.};
495 const Double_t kssdmodulerottheta[7] = { 0., 0., 0., 0., 0., 0., 0.};
496 const Double_t kssdmodulerotpsi[7] = { 0., 0., 0., 0., 0., 0., 0.};
497 ////////////////////////////////////////////////////////
498 //Name of CombiTrans Transformation of SSDModuleAssembly:
499 ////////////////////////////////////////////////////////
500 const char* ssdmodulecombitransname[7] = {"SSDStiffenerCombiTrans",
501 "SSDChipCombiTrans",
502 "SSDSensorCombiTrans",
503 "SSDFlex0CombiTrans",
504 "SSDCoolingBlockCombiTrans",
505 "SSDChipCablesCombiTrans",
506 "SSDFlex1CombiTrans"};
507 const char* ssdmodulerotname[7] = {"SSDStiffenerRotName",
508 "SSDChipRotName",
509 "SSDSensorRotName",
510 "SSDFlex0RotName",
511 "SSDCoolingBlockRotName",
512 "SSDChipCablesRotName",
513 "SSDFlex1RotName"};
514 TGeoCombiTrans *ssdmodulelocalmatrix[fgkSSDModuleCombiTransNumber];
515 for(Int_t i=0; i<fgkSSDModuleCombiTransNumber; i++){
516 ssdmodulelocalmatrix[i] =
517 new TGeoCombiTrans(ssdmodulecombitransname[i],
518 kssdmoduletransx[i],
519 kssdmoduletransy[i],
520 kssdmoduletransz[i],
521 new TGeoRotation(ssdmodulerotname[i],
522 kssdmodulerotphi[i],
523 kssdmodulerottheta[i],
524 kssdmodulerotpsi[i]));
525 fSSDModuleCombiTransMatrix[i] = ssdmodulelocalmatrix[i];
526 }
527}
528/////////////////////////////////////////////////////////////////////////////////
529void AliITSv11GeometrySSD::SetCarbonFiberJunctionCombiTransMatrix(){
530 /////////////////////////////////////////////////////////////
531 // Method generating CombiTrans Matrix for Carbon Fiber Junction
532 /////////////////////////////////////////////////////////////
533 //Translation Parameters CarbonFiberJunction:
534 ////////////////////////////////////////////////////////
535 const Double_t kcarbonfiberjunctiontransx[3] =
536 { 0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
537 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
538 const Double_t kcarbonfiberjunctiontransy[3] =
539 { 0.0, 0.0,fgkCarbonFiberTriangleLength
540 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
541 const Double_t kcarbonfiberjunctiontransz[3] = { 0.0, 0.0, 0.0};
542 ////////////////////////////////////////////////////////
543 //Rotational Parameters CarbonFiberJunction:
544 ////////////////////////////////////////////////////////
545 const Double_t kcarbonfiberjunctionrotphi[3] = { 0., 120., 240.};
546 const Double_t kcarbonfiberjunctionrottheta[3] = { 0., 0., 0.};
547 const Double_t kcarbonfiberjunctionrotpsi[3] = { 0., 0., 0.};
548 ///////////////////////////////////////////////////////////
549 //Name of CombiTrans Transformation of CarbonFiberJunction:
550 ///////////////////////////////////////////////////////////
551 char carbonfiberjunctioncombitransname[40];
552 char carbonfiberjunctionrotname[40];
553 TGeoCombiTrans *carbonfiberjunctionlocalmatrix[fgkCarbonFiberJunctionCombiTransNumber];
554 for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber; i++) {
555 sprintf(carbonfiberjunctioncombitransname,"CarbonFiberJunctionCombiTrans%i",i);
556 sprintf(carbonfiberjunctionrotname,"CarbonFiberJunctionRot%i",i);
557 carbonfiberjunctionlocalmatrix[i] =
558 new TGeoCombiTrans(carbonfiberjunctioncombitransname,
559 kcarbonfiberjunctiontransx[i],
560 kcarbonfiberjunctiontransy[i],
561 kcarbonfiberjunctiontransz[i],
562 new TGeoRotation(carbonfiberjunctionrotname,
563 kcarbonfiberjunctionrotphi[i],
564 kcarbonfiberjunctionrottheta[i],
565 kcarbonfiberjunctionrotpsi[i]));
566 fCarbonFiberJunctionCombiTransMatrix[i] = carbonfiberjunctionlocalmatrix[i];
567 }
568}
569/////////////////////////////////////////////////////////////////////////////////
570void AliITSv11GeometrySSD::SetEndLadderCarbonFiberJunctionCombiTransMatrix(Int_t i){
571 /////////////////////////////////////////////////////////////
572 // Method generating CombiTrans Matrix for End Ladder Carbon Fiber Junction
573 /////////////////////////////////////////////////////////////
574 //Translation Parameters EndLadderCarbonFiberJunction:
575 ////////////////////////////////////////////////////////
576 const Double_t kendladdercarbonfiberjunctiontransx[3] =
577 { 0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
578 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
579 const Double_t kendladdercarbonfiberjunctiontransy[3] =
580 { 0.0, 0.0,fgkCarbonFiberTriangleLength
581 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
582 const Double_t kendladdercarbonfiberjunctiontransz[3] = { 0.0, 0.0,
583 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
584 -fgkEndLadderCarbonFiberUpperJunctionLength[i])};
585 ////////////////////////////////////////////////////////
586 //Rotational Parameters EndLadderCarbonFiberJunction:
587 ////////////////////////////////////////////////////////
588 const Double_t kendladdercarbonfiberjunctionrotphi[3] = { 0., 120., 240.};
589 const Double_t kendladdercarbonfiberjunctionrottheta[3] = { 0., 0., 0.};
590 const Double_t kendladdercarbonfiberjunctionrotpsi[3] = { 0., 0., 0.};
591 ///////////////////////////////////////////////////////////
592 //Name of CombiTrans Transformation of CarbonFiberJunction:
593 ///////////////////////////////////////////////////////////
594 char endladdercarbonfiberjunctioncombitransname[40];
595 char endladdercarbonfiberjunctionrotname[40];
596 TGeoCombiTrans *endladdercarbonfiberjunctionlocalmatrix[fgkEndLadderCarbonFiberJunctionCombiTransNumber];
597 for(Int_t i=0; i<fgkEndLadderCarbonFiberJunctionCombiTransNumber; i++) {
598 sprintf(endladdercarbonfiberjunctioncombitransname,"EndLadderCarbonFiberJunctionCombiTrans%i",i);
599 sprintf(endladdercarbonfiberjunctionrotname,"EndLadderCarbonFiberJunctionRot%i",i);
600 endladdercarbonfiberjunctionlocalmatrix[i] =
601 new TGeoCombiTrans(endladdercarbonfiberjunctioncombitransname,
602 kendladdercarbonfiberjunctiontransx[i],
603 kendladdercarbonfiberjunctiontransy[i],
604 kendladdercarbonfiberjunctiontransz[i],
605 new TGeoRotation(endladdercarbonfiberjunctionrotname,
606 kendladdercarbonfiberjunctionrotphi[i],
607 kendladdercarbonfiberjunctionrottheta[i],
608 kendladdercarbonfiberjunctionrotpsi[i]));
609 fEndLadderCarbonFiberJunctionCombiTransMatrix[i] =
610 endladdercarbonfiberjunctionlocalmatrix[i];
611 }
612}
613////////////////////////////////////////////////////////////////////////////////
614void AliITSv11GeometrySSD::SetCarbonFiberAssemblyCombiTransMatrix(){
615 /////////////////////////////////////////////////////////////
616 // Method generating CombiTrans Matrix for Carbon fiber Assembly
617 /////////////////////////////////////////////////////////////
618 //Translation Parameters CarbonFiberAssembly:
619 ////////////////////////////////////////////////////////
620 const Double_t kcarbonfiberassemblytransx[3] = { 0.0, 0.0, 0.0};
621 const Double_t kcarbonfiberassemblytransy[3] =
622 { 0.5*fgkCarbonFiberJunctionWidth, 0.0,
623 fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
624 - fgkCarbonFiberLowerSupportVolumePosition[0]
625 - fgkCarbonFiberLowerSupportVolumePosition[1]};
626 const Double_t kcarbonfiberassemblytransz[3] =
627 { 0.0, 0.0,- 0.5*fgkCarbonFiberLowerSupportHeight};
628 ////////////////////////////////////////////////////////
629 //Rotational Parameters CarbonFiberAssembly:
630 ////////////////////////////////////////////////////////
631 const Double_t kcarbonfiberassemblyrotphi[3] = { 0., 90., 0.};
632 const Double_t kcarbonfiberassemblyrottheta[3] = { 90.,
633 -fgkCarbonFiberTriangleAngle, 0.};
634 const Double_t kcarbonfiberassemblyrotpsi[3] = { 0.,- 90., 0.};
635 ///////////////////////////////////////////////////////////
636 //Name of CombiTrans Transformation of CarbonFiberAssembly:
637 ///////////////////////////////////////////////////////////
638 char carbonfiberassemblycombitransname[30];
639 char carbonfiberassemblyrotname[30];
640 TGeoCombiTrans *carbonfiberassemblylocalmatrix[fgkCarbonFiberAssemblyCombiTransNumber];
641 for(Int_t i=0; i<fgkCarbonFiberAssemblyCombiTransNumber; i++) {
642 sprintf(carbonfiberassemblycombitransname,"CarbonFiberAssemblyCombiTrans%i",i);
643 sprintf(carbonfiberassemblyrotname,"CarbonFiberAssemblyRot%i",i);
644 carbonfiberassemblylocalmatrix[i] =
645 new TGeoCombiTrans(carbonfiberassemblycombitransname,
646 kcarbonfiberassemblytransx[i],
647 kcarbonfiberassemblytransy[i],
648 kcarbonfiberassemblytransz[i],
649 new TGeoRotation(carbonfiberassemblyrotname,
650 kcarbonfiberassemblyrotphi[i],
651 kcarbonfiberassemblyrottheta[i],
652 kcarbonfiberassemblyrotpsi[i]));
653 fCarbonFiberAssemblyCombiTransMatrix[i] = carbonfiberassemblylocalmatrix[i];
654 }
655}
656/////////////////////////////////////////////////////////////////////////////////
657void AliITSv11GeometrySSD::SetCoolingTubeSupportCombiTransMatrix(){
658 /////////////////////////////////////////////////////////////
659 // Method generating CombiTrans Matrix for Cooling Tube Support
660 /////////////////////////////////////////////////////////////
661 //Translation Parameters CoolingTubeSupport:
662 ////////////////////////////////////////////////////////
663 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
664 /fgkCoolingTubeSupportRmax);
665 const Double_t kcoolingtubesupporttransx[2] =
666 {0.,2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
667 + 2.*(fgkCoolingTubeSupportLength
668 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
669 + fgkCarbonFiberTriangleLength
670 - 2.0*fgkCarbonFiberJunctionLength};
671 const Double_t kcoolingtubesupporttransy[2] = { 0.0, 0.0};
672 const Double_t kcoolingtubesupporttransz[2] = { 0.0, 0.0};
673 ////////////////////////////////////////////////////////
674 //Rotational Parameters CoolingTubeSupport:
675 ////////////////////////////////////////////////////////
676 const Double_t kcoolingsubesupportrotphi[2] = { 0., 180.};
677 const Double_t kcoolingsubesupportrottheta[2] = { 0., 0.};
678 const Double_t kcoolingsubesupportrotpsi[2] = { 0., 0.};
679 ///////////////////////////////////////////////////////////
680 //Name of CombiTrans Transformation of CarbonFiberJunction:
681 ///////////////////////////////////////////////////////////
682 char coolingtubesupportcombitransname[40];
683 char coolingtubesupportrotname[40];
684 TGeoCombiTrans *coolingtubesupportlocalmatrix[fgkCoolingTubeSupportCombiTransNumber];
685 for(Int_t i=0; i<fgkCoolingTubeSupportCombiTransNumber; i++) {
686 sprintf(coolingtubesupportcombitransname,"CoolingTubeSupportCombiTrans%i",i);
687 sprintf(coolingtubesupportrotname,"CoolingTubeSupportRot%i",i);
688 coolingtubesupportlocalmatrix[i] =
689 new TGeoCombiTrans(coolingtubesupportcombitransname,
690 kcoolingtubesupporttransx[i],
691 kcoolingtubesupporttransy[i],
692 kcoolingtubesupporttransz[i],
693 new TGeoRotation(coolingtubesupportrotname,
694 kcoolingsubesupportrotphi[i],
695 kcoolingsubesupportrottheta[i],
696 kcoolingsubesupportrotpsi[i]));
697 fCoolingTubeSupportCombiTransMatrix[i] = coolingtubesupportlocalmatrix[i];
698 }
699}
700/////////////////////////////////////////////////////////////////////////////////
701void AliITSv11GeometrySSD::SetCoolingTubeCombiTransMatrix(){
702 /////////////////////////////////////////////////////////////
703 // Method generating CombiTrans Matrix for Cooling Tube
704 /////////////////////////////////////////////////////////////
705 //Translation Parameters CoolingTube:
706 ////////////////////////////////////////////////////////
707 const Double_t kcoolingtubetransx[2] = { 0., fgkCoolingTubeSeparation};
708 const Double_t kcoolingtubetransy[2] = { fgkCoolingTubeLength/2.0, fgkCoolingTubeLength/2.0};
709 const Double_t kcoolingtubetransz[2] = { 0.0, 0.};
710 ////////////////////////////////////////////////////////
711 //Rotational Parameters CoolingTube:
712 ////////////////////////////////////////////////////////
713 const Double_t kcoolingtuberotphi[2] = { 0., 0.};
714 const Double_t kcoolingtuberottheta[2] = { 90., 90.};
715 const Double_t kcoolingtuberotpsi[2] = { 0., 0.};
716 ///////////////////////////////////////////////////////////
717 //Name of CombiTrans Transformation of CarbonFiberJunction:
718 ///////////////////////////////////////////////////////////
719 const char* coolingtubecombitransname[fgkCoolingTubeCombiTransNumber] =
720 {"CoolingTubeCombiTrans0","CoolingTubeCombiTrans1"};
721 const char* coolingtuberotationname[fgkCoolingTubeCombiTransNumber] =
722 {"CoolingTubeRotation0","CoolingTubeRotation1"};
723 TGeoCombiTrans *coolingtubelocalmatrix[fgkCoolingTubeCombiTransNumber];
724 for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber; i++) {
725 coolingtubelocalmatrix[i] =
726 new TGeoCombiTrans(coolingtubecombitransname[i],
727 kcoolingtubetransx[i],
728 kcoolingtubetransy[i],
729 kcoolingtubetransz[i],
730 new TGeoRotation(coolingtuberotationname[i],
731 kcoolingtuberotphi[i],
732 kcoolingtuberottheta[i],
733 kcoolingtuberotpsi[i]) );
734 fCoolingTubeTransMatrix[i] = coolingtubelocalmatrix[i];
735 }
736}
737/////////////////////////////////////////////////////////////////////////////////
738void AliITSv11GeometrySSD::SetLadderSegmentCombiTransMatrix(){
739 /////////////////////////////////////////////////////////////
740 // Method generating CombiTrans Matrix for SSD Ladder Segment
741 /////////////////////////////////////////////////////////////
742 //Translation Parameters LadderSegment:
743 ////////////////////////////////////////////////////////
744 const Double_t kladdersegmenttransx[fgkLadderSegmentCombiTransNumber] = { 0.,
745 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
746 fgkCarbonFiberTriangleLength+fgkCarbonFiberJunctionToSensorSupport,
747 fgkCarbonFiberJunctionLength-(fgkCoolingTubeSupportLength
748 - fgkCoolingTubeSupportRmax),
749 0.5*(fgkCarbonFiberTriangleLength-fgkCoolingTubeSeparation)};
750 const Double_t kladdersegmenttransy[fgkLadderSegmentCombiTransNumber] = { 0.,
751 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
752 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
753 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
754 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
755 - fgkSSDSensorCenterSupportThickness[0]),
756 fgkCarbonFiberJunctionWidth-0.5*(fgkCarbonFiberLowerSupportWidth
757 + fgkSSDSensorCenterSupportLength
758 - fgkSSDSensorCenterSupportThickness[0])
759 - fgkSSDSensorCenterSupportPosition,
760 fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
761 - fgkCoolingTubeSupportToCarbonFiber,
762 0.0};
763 const Double_t kladdersegmenttransz[fgkLadderSegmentCombiTransNumber] = { 0.,
764 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
765 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight),
766 0.,
767 - 0.5*fgkCoolingTubeSupportHeight,
768 - 0.5*fgkCoolingTubeSupportHeight};
769//////////////////////////////////////////////////
770 //Rotational Parameters LadderSegment:
771 ////////////////////////////////////////////////////////
772 const Double_t kladdersegmentrotphi[fgkLadderSegmentCombiTransNumber] =
773 { 0., 0.,- 90., 0., 0.};
774 const Double_t kladdersegmentrottheta[fgkLadderSegmentCombiTransNumber] =
775 { 0., 0., 0., 90., 0.};
776 const Double_t kladdersegmentrotpsi[fgkLadderSegmentCombiTransNumber] =
777 { 0., 0., 0., 0., 0.};
778 //////////////////////////////////////////////////////
779 //Name of CombiTrans Transformation of LadderSegment:
780 //////////////////////////////////////////////////////
781 char laddersegmentcombitransname[40];
782 char laddersegmentrotname[40];
783 TGeoCombiTrans *laddersegmentlocalmatrix[fgkLadderSegmentCombiTransNumber];
784 for(Int_t i=0; i<fgkLadderSegmentCombiTransNumber; i++) {
785 sprintf(laddersegmentcombitransname,"LadderSegmentCombiTrans%i",i);
786 sprintf(laddersegmentrotname,"LadderSegmentRot%i",i);
787 laddersegmentlocalmatrix[i] =
788 new TGeoCombiTrans(laddersegmentcombitransname,
789 kladdersegmenttransx[i],
790 kladdersegmenttransy[i],
791 kladdersegmenttransz[i],
792 new TGeoRotation(laddersegmentrotname,
793 kladdersegmentrotphi[i],
794 kladdersegmentrottheta[i],
795 kladdersegmentrotpsi[i]));
796 fLadderSegmentCombiTransMatrix[i] = laddersegmentlocalmatrix[i];
797 }
798}
799/////////////////////////////////////////////////////////////////////////////////
800void AliITSv11GeometrySSD::SetEndLadderSegmentCombiTransMatrix(Int_t i){
801 /////////////////////////////////////////////////////////////
802 // Method generating CombiTrans Matrix for SSD End Ladder Segment
803 /////////////////////////////////////////////////////////////
804 //Translation Parameters EndLadderSegment:
805 ////////////////////////////////////////////////////////
806 const Double_t kendladdersegmenttransx[fgkEndLadderSegmentCombiTransNumber] =
807 {0.0,
808 0.0,
809 - 0.25*(fgkSSDMountingBlockLength[0]
810 + fgkSSDMountingBlockLength[1])
811 + 0.5*fgkCarbonFiberTriangleLength,
812 0.0};
813 const Double_t kendladdersegmenttransy[fgkEndLadderSegmentCombiTransNumber] =
814 {0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],
815 i==0 ? 0. : fgkCarbonFiberLowerSupportWidth,
816 fgkEndLadderMountingBlockPosition[i],
817 (1-i)*(fgkEndLadderMountingBlockPosition[i]
818 + 0.5*fgkSSDMountingBlockWidth)};
819 const Double_t kendladdersegmenttransz[fgkEndLadderSegmentCombiTransNumber] =
820 {0.0,
821 0.0,
822 - fgkSSDMountingBlockHeight[1]
823 + 0.5*fgkSSDMountingBlockHeight[0],
824 - 0.5*fgkCarbonFiberLowerSupportHeight};
825 ////////////////////////////////////////////////////////
826 //Rotational Parameters EndLadderSegment:
827 ////////////////////////////////////////////////////////
828 const Double_t kendladdersegmentrotphi[fgkEndLadderSegmentCombiTransNumber] =
829 { 0., 90., 0., 0.};
830 const Double_t kendladdersegmentrottheta[fgkEndLadderSegmentCombiTransNumber] =
831 { 90.,-fgkCarbonFiberTriangleAngle, 0., 0.};
832 const Double_t kendladdersegmentrotpsi[fgkEndLadderSegmentCombiTransNumber] =
833 { 0.,- 90., 0., 0.};
834 ////////////////////////////////////////////////////////
835 //Name of CombiTrans Transformation of EndLadderSegment:
836 ////////////////////////////////////////////////////////
837 char endladdersegmentcombitransname[30];
838 char endladdersegmentrotname[30];
839 TGeoCombiTrans *endladdersegmentlocalmatrix[fgkEndLadderSegmentCombiTransNumber];
840 for(Int_t i=0; i<fgkEndLadderSegmentCombiTransNumber; i++){
841 sprintf(endladdersegmentcombitransname,"EndLadderSegmentCombiTrans%i",i);
842 sprintf(endladdersegmentrotname,"EndLadderSegmentRot%i",i);
843 endladdersegmentlocalmatrix[i] =
844 new TGeoCombiTrans(endladdersegmentcombitransname,
845 kendladdersegmenttransx[i],
846 kendladdersegmenttransy[i],
847 kendladdersegmenttransz[i],
848 new TGeoRotation(endladdersegmentrotname,
849 kendladdersegmentrotphi[i],
850 kendladdersegmentrottheta[i],
851 kendladdersegmentrotpsi[i]));
852 fEndLadderSegmentCombiTransMatrix[i] = endladdersegmentlocalmatrix[i];
853 }
854}
855/////////////////////////////////////////////////////////////////////////////////
856void AliITSv11GeometrySSD::SetLadderCableCombiTransMatrix(Int_t iLayer){
857 /////////////////////////////////////////////////////////////
858 // Method generating CombiTrans Matrix for SSD Ladder Cable
859 /////////////////////////////////////////////////////////////
860 // Translation Parameters for LadderCable
861 /////////////////////////////////////////
862 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
863 + fgkSSDFlexHeight[1];
864 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
865 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
866 Double_t ssdladdercabletransx[3];
867 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
868 * TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())
869 * TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
870 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
871 - ssdladdercabletransx[0]
872 / TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad()))
873 * TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad());
874 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
875 * TMath::DegToRad()*ssdflexradiusmax
876 - fgkSSDFlexLength[2]-TMath::Pi()
877 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
878 - fgkSSDLadderCableWidth)
879 * TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
880 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
881 * TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad()),
882 ssdladdercabletransx[1]
883 * TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad()),
884 ssdladdercabletransx[2]
885 * TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad())};
886 TGeoRotation* localladdercablerot[3];
887 localladdercablerot[0] = new TGeoRotation("LocalLadderCableRot0",90.,0.,0.);
888 localladdercablerot[1] = new TGeoRotation("LocalLadderCableRot1",90.,60.,-90.);
889 localladdercablerot[2] = new TGeoRotation("LocalLadderCableRot2");
890 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
891 * (*localladdercablerot[0]));
892 ////////////////////////////////////////////
893 // LocalLadderCableCombiTransMatrix
894 ////////////////////////////////////////////
895 const Int_t klocalladdersidecablesnumber = 2;
896 const Int_t klocalladdercombitransnumber = 5;
897 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
898 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
899 localladdercablecombitransmatrix[i] =
900 new TGeoCombiTrans*[klocalladdercombitransnumber];
901 ///////////////////////////////////////////
902 // Left Side Ladder Cables Transformations
903 ///////////////////////////////////////////
904 localladdercablecombitransmatrix[0][0] =
905 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
906 0.,0.,NULL);
907 localladdercablecombitransmatrix[0][1] = fLadderSegmentCombiTransMatrix[1];
908 localladdercablecombitransmatrix[0][2] =
909 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
910 fgkSSDModuleStiffenerPosition[1],0.,0);
911 localladdercablecombitransmatrix[0][3] = fSSDModuleCombiTransMatrix[6];
912 localladdercablecombitransmatrix[0][4] =
913 new TGeoCombiTrans(-ssdladdercabletransx[0]
914 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
915 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
916 0.,
917 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
918 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
919 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
920 + ssdladdercabletransz[2],localladdercablerot[2]);
921 ///////////////////////////////////////////
922 // Rigth Side Ladder Cables Transformations
923 ///////////////////////////////////////////
924 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
925 localladdercablecombitransmatrix[1][i] =
926 (i!=3 ? localladdercablecombitransmatrix[0][i]:
927 fSSDModuleCombiTransMatrix[3]);
928 ///////////////////////////////////////////
929 // Setting LadderCableCombiTransMatrix
930 ///////////////////////////////////////////
931 Int_t beamaxistrans[3] = {0,0,0};
932 switch(iLayer){
933 case 5:
934 beamaxistrans[0] = fgkSSDLay5SensorsNumber/2;
935 beamaxistrans[1] = beamaxistrans[0]+1;
936 beamaxistrans[2] = beamaxistrans[0]-1;
937 break;
938 case 6:
939 beamaxistrans[0] = (fgkSSDLay6SensorsNumber-1)/2;
940 beamaxistrans[1] = beamaxistrans[0]+1;
941 beamaxistrans[2] = beamaxistrans[0];
942 break;
943 }
944 TGeoHMatrix* localladdercablehmatrix[klocalladdersidecablesnumber];
945 TGeoRotation* laddercablerot;
946 TGeoTranslation* laddercabletrans;
947 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
948 localladdercablehmatrix[i] = new TGeoHMatrix();
949 for(Int_t j=0; j<klocalladdercombitransnumber; j++){
950 localladdercablehmatrix[i]->MultiplyLeft(
951 localladdercablecombitransmatrix[i][klocalladdercombitransnumber-j-1]);
952 }
953 laddercablerot = new TGeoRotation();
954 laddercablerot->SetMatrix(localladdercablehmatrix[i]->GetRotationMatrix());
955 laddercabletrans = new TGeoTranslation();
956 Double_t* laddercabletransvector = localladdercablehmatrix[i]->GetTranslation();
957 laddercabletrans->SetTranslation(laddercabletransvector[0],
958 laddercabletransvector[1]
959 + (i==0 ? beamaxistrans[0] : 0.)
960 * fgkCarbonFiberJunctionWidth,
961 laddercabletransvector[2]);
962 fLadderCableCombiTransMatrix[i] = new TGeoCombiTrans(*laddercabletrans,
963 *laddercablerot);
964 }
965 fLadderCableCombiTransMatrix[2] =
966 AddTranslationToCombiTrans(fLadderCableCombiTransMatrix[1],0.,
967 beamaxistrans[1]*fgkCarbonFiberJunctionWidth,0.);
968 fLadderCableCombiTransMatrix[3] =
969 AddTranslationToCombiTrans(fLadderCableCombiTransMatrix[0],0.,
970 beamaxistrans[2]*fgkCarbonFiberJunctionWidth,0.);
971}
972/////////////////////////////////////////////////////////////////////////////////
973TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportShape(Double_t length,
974 Double_t height,Double_t width,Double_t* thickness){
975 /////////////////////////////////////////////////////////////
976 // Method generating SSD Sensor Support Shape
977 /////////////////////////////////////////////////////////////
978 const Int_t kvertexnumber = 4;
979 const Int_t kshapesnumber = 2;
980 Double_t shapewidth[2] = {width,width};
981 TVector3** vertexposition[kshapesnumber];
982 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
983 new TVector3*[kvertexnumber];
984 //First Shape Vertex Positioning
985 vertexposition[0][0] = new TVector3();
986 vertexposition[0][1] = new TVector3(height);
987 vertexposition[0][2] = new TVector3(thickness[0]);
988 vertexposition[0][3] = new TVector3(*vertexposition[0][1]);
989 //Second Shape Vertex Positioning
990 vertexposition[1][0] = new TVector3(*vertexposition[0][0]);
991 vertexposition[1][1] = new TVector3(length);
992 vertexposition[1][2] = new TVector3(thickness[1]);
993 vertexposition[1][3] = new TVector3(vertexposition[1][1]->X());
994 char* ssdsensorsupportshapename[kshapesnumber] =
995 {"SSDSensorSupportShape1","SSDSensorSupportShape2"};
996 TGeoArb8* lSSDSensorSupportShape[kshapesnumber];
997 for(Int_t i = 0; i< kshapesnumber; i++) lSSDSensorSupportShape[i] =
998 GetArbShape(vertexposition[i],shapewidth,i==0 ?
999 thickness[1]: thickness[0],
1000 ssdsensorsupportshapename[i]);
1001 /////////////////////////////////////
1002 //Setting Translations and Rotations:
1003 /////////////////////////////////////
1004 TGeoRotation* ssdsensorsupportshaperot[2];
1005 ssdsensorsupportshaperot[0] =
1006 new TGeoRotation("SSDSensorSupportShapeRot1",180.,0.,0.);
1007 ssdsensorsupportshaperot[1] =
1008 new TGeoRotation("SSDSensorSupportShapeRot2",90.,90.,-90.);
1009 TGeoTranslation* ssdsensorsupportshapetrans =
1010 new TGeoTranslation("SSDSensorSupportShapeTrans",0.,0.,
1011 0.5*thickness[0]);
1012 TGeoCombiTrans* ssdsensorsupportcombitrans =
1013 new TGeoCombiTrans("SSDSensorSupportCombiTrans",0.5*thickness[0],width,0.,
1014 new TGeoRotation((*ssdsensorsupportshaperot[1])
1015 * (*ssdsensorsupportshaperot[0])));
1016 TGeoVolume* ssdsensorsupportcompvolume =
1017 new TGeoVolumeAssembly("SSDSensorSupportCompVolume");
1018 ssdsensorsupportcompvolume->AddNode(new TGeoVolume("SSDSensorSupportVolume1",
1019 lSSDSensorSupportShape[0],fSSDSensorSupportMedium),1,
1020 ssdsensorsupportshapetrans);
1021 ssdsensorsupportcompvolume->AddNode(new TGeoVolume("SSDSensorSupportVolume2",
1022 lSSDSensorSupportShape[1],fSSDSensorSupportMedium),1,
1023 ssdsensorsupportcombitrans);
1024 return ssdsensorsupportcompvolume;
1025}
1026/////////////////////////////////////////////////////////////////////////////////
1027TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Int_t VolumeKind, Int_t n){
1028 /////////////////////////////////////////////////////////////
1029 // Method generating SSD Sensor Support
1030 /////////////////////////////////////////////////////////////
1031 TGeoVolume* ssdsensorsupport;
1032 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
1033 fgkSSDSensorSideSupportThickness[1]};
1034 VolumeKind == 0 ? ssdsensorsupport = GetSSDSensorSupportShape(
1035 fgkSSDSensorSideSupportLength,
1036 fgkSSDSensorSideSupportHeight[(n==0 ? 0 : 1)],
1037 fgkSSDSensorSideSupportWidth,
1038 sidesupporthickness) :
1039 ssdsensorsupport = GetSSDSensorSupportShape(fgkSSDSensorCenterSupportLength,
1040 fgkSSDSensorCenterSupportHeight[(n==0 ? 0 : 1)],
1041 fgkSSDSensorCenterSupportWidth,
1042 sidesupporthickness);
1043 return ssdsensorsupport;
1044}
1045/////////////////////////////////////////////////////////////////////////////////
1046TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportAssembly(Int_t n){
1047 /////////////////////////////////////////////////////////////
1048 // Method generating SSD Sensor Support Assembly
1049 /////////////////////////////////////////////////////////////
1050 TGeoVolume* ssdsensorsupportassembly =
1051 new TGeoVolumeAssembly("SSDSensorSupportAssembly");
1052 const Int_t kvolumenumber = 2;
1053 TGeoVolume* ssdsensorsupport[kvolumenumber];
1054 for(Int_t i=0; i<kvolumenumber; i++) ssdsensorsupport[i] =
1055 GetSSDSensorSupport(i,n);
1056 SetSSDSensorSupportCombiTransMatrix();
1057 for(Int_t i=0; i<fgkSSDSensorSupportCombiTransNumber; i++)
1058 ssdsensorsupportassembly->AddNode((i<2 ? ssdsensorsupport[0]:
1059 ssdsensorsupport[1]),
1060 i+1,fSSDSensorSupportCombiTransMatrix[i]);
1061 return ssdsensorsupportassembly;
1062}
1063/////////////////////////////////////////////////////////////////////////////////
1064TGeoVolume* AliITSv11GeometrySSD::GetSSDModule(Int_t iChipCablesHeight){
1065 /////////////////////////////////////////////////////////////
1066 // Method generating SSD Sensor Module
1067 /////////////////////////////////////////////////////////////
1068 TGeoVolume* ssdmodulevolume[fgkSSDModuleCombiTransNumber-1];
1069 ssdmodulevolume[0] = GetSSDStiffenerAssembly();
1070 ssdmodulevolume[1] = GetSSDChipAssembly();
1071 ssdmodulevolume[2] = GetSSDSensor();
1072 ssdmodulevolume[3] = GetSSDFlexAssembly();
1073 ssdmodulevolume[4] = GetSSDCoolingBlockAssembly();
1074 ssdmodulevolume[5] = GetSSDChipCablesAssembly(fgkSSDChipCablesHeight[iChipCablesHeight+2]);
1075 SetSSDModuleCombiTransMatrix(fgkSSDChipCablesHeight[iChipCablesHeight+2]);
1076 TGeoCombiTrans* ssdmoduleglobalcombitrans =
1077 new TGeoCombiTrans("SSDModuleGlobalCombiTrans",
1078 fgkSSDModuleStiffenerPosition[0],
1079 fgkSSDModuleStiffenerPosition[1],0.,NULL);
1080 TGeoHMatrix* ssdmodulehmatrix[fgkSSDModuleCombiTransNumber];
1081 TGeoVolume* ssdmodule = new TGeoVolumeAssembly("SSDModule");
1082 for(Int_t i=0; i<fgkSSDModuleCombiTransNumber; i++){
1083 ssdmodulehmatrix[i] = new TGeoHMatrix((*ssdmoduleglobalcombitrans)
1084 * (*fSSDModuleCombiTransMatrix[i]));
1085 ssdmodule->AddNode(i==fgkSSDModuleCombiTransNumber-1 ? ssdmodulevolume[3] :
1086 ssdmodulevolume[i],i!=fgkSSDModuleCombiTransNumber-1?1:2,
1087 ssdmodulehmatrix[i]);
1088 }
1089 return ssdmodule;
1090}
1091/////////////////////////////////////////////////////////////////////////////////
1092TGeoVolume* AliITSv11GeometrySSD::GetSSDSensor(){
1093 /////////////////////////////////////////////////////////////
1094 // Method generating SSD Sensor
1095 /////////////////////////////////////////////////////////////
1096 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1097 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1098 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
1099 0.5*ssdsensitivelength,
1100 0.5*ssdsensitivewidth,
1101 0.5*fgkSSDSensorHeight);
1102 TGeoVolume* ssdsensorsensitive =
1103 new TGeoVolume(fgkSSDSensitiveVolName,ssdsensorsensitiveshape,fSSDSensorMedium);
1104 ssdsensorsensitive->SetLineColor(fColorSilicon);
1105 TGeoBBox* ssdsensorinsensitiveshape[2];
1106 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
1107 0.5*fgkSSDSensorLength,
1108 0.5*fgkSSDSensorInsensitiveWidth,
1109 0.5*fgkSSDSensorHeight);
1110 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
1111 0.5*fgkSSDSensorInsensitiveWidth,
1112 0.5*ssdsensitivewidth,
1113 0.5*fgkSSDSensorHeight);
1114 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
1115 "SSDSensorInsensitive2"};
1116 TGeoVolume* ssdsensorinsensitive[2];
1117 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1118 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1119 fSSDSensorMedium);
1120 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
1121 }
1122 TGeoVolume* ssdsensorinsensitivevol =
1123 new TGeoVolumeAssembly("SSDSensorInsensitiveVol");
1124 for(Int_t i=0; i<4; i++)
1125 ssdsensorinsensitivevol->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1126 ssdsensorinsensitive[1],i<2?1:2,
1127 new TGeoTranslation(0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1128 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[1]->GetDX()),
1129 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1130 * (ssdsensorsensitiveshape->GetDY()+ssdsensorinsensitiveshape[0]->GetDY()),0.));
1131 TGeoVolume* ssdsensor = new TGeoVolumeAssembly("SSDSensor");
1132 ssdsensor->AddNode(ssdsensorsensitive,1),ssdsensor->AddNode(ssdsensorinsensitivevol,1);
1133 return ssdsensor;
1134}
1135/////////////////////////////////////////////////////////////////////////////////
1136TGeoVolume* AliITSv11GeometrySSD::GetSSDChipAssembly() const{
1137 /////////////////////////////////////////////////////////////
1138 // Method generating SSD Chip Assembly
1139 /////////////////////////////////////////////////////////////
1140 const Int_t kssdchiprownumber = 2;
1141 TGeoBBox* ssdchipcompshape[2];
1142 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
1143 0.5*fgkSSDChipLength,
1144 0.5*fgkSSDChipWidth,
1145 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
1146 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
1147 0.5*fgkSSDChipLength,
1148 0.5*fgkSSDChipWidth,
1149 0.5*fgkSSDChipGlueHeight);
1150 TGeoVolume* ssdchipcomp[2];
1151 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
1152 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
1153 fSSDChipGlueMedium);
1154 ssdchipcomp[0]->SetLineColor(fColorSilicon);
1155 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
1156 TGeoTranslation* ssdchipcomptrans[2];
1157 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
1158 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
1159 TGeoVolume* ssdchip = new TGeoVolumeAssembly("SSDChip");
1160 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
1161 Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
1162 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1163 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
1164 - 0.5*fgkSSDChipWidth)};
1165 TGeoVolume* ssdchipassembly = new TGeoVolumeAssembly("SSDChipAssembly");
1166 for(Int_t i=0; i<kssdchiprownumber; i++)
1167 for(Int_t j=0; j<fgkSSDChipNumber; j++)
1168 ssdchipassembly->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
1169 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
1170 return ssdchipassembly;
1171}
1172/////////////////////////////////////////////////////////////////////////////////
1173TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerAssembly(){
1174 /////////////////////////////////////////////////////////////
1175 // Method generating SSD Stiffener Assembly
1176 /////////////////////////////////////////////////////////////
1177 const Int_t kssdstiffenernumber = 2;
1178 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1179 - 2.*fgkSSDModuleStiffenerPosition[1]
1180 - fgkSSDStiffenerWidth;
1181 TGeoVolume* ssdstiffener = new TGeoVolumeAssembly("SSDStiffener");
1182////////////////////////////
1183// Stiffener Volumes
1184///////////////////////////
1185 const Int_t kstiffenerboxnumber = 6;
1186 TGeoBBox* ssdstiffenerboxshapes[kstiffenerboxnumber];
1187 ssdstiffenerboxshapes[0] = new TGeoBBox("SSDStiffenerBoxShape1",
1188 0.5* fgkSSDStiffenerLength,
1189 0.5* fgkSSDStiffenerWidth,
1190 0.5*(fgkSSDStiffenerHeight
1191 - fgkSSDConnectorHeight));
1192 ssdstiffenerboxshapes[1] = new TGeoBBox("SSDStiffenerBoxShape2",
1193 0.5*(fgkSSDConnectorPosition[0]
1194 - 2.0* fgkSSDConnectorLength
1195 - fgkSSDConnectorSeparation),
1196 0.5* fgkSSDStiffenerWidth,
1197 0.5* fgkSSDConnectorHeight);
1198 ssdstiffenerboxshapes[2] = new TGeoBBox("SSDStiffenerBoxShape3",
1199 0.5*(fgkSSDConnectorSeparation
1200 + 2.* fgkSSDConnectorLength),
1201 0.5* fgkSSDConnectorPosition[1],
1202 0.5* fgkSSDConnectorHeight);
1203 ssdstiffenerboxshapes[3] = new TGeoBBox("SSDStiffenerBoxShape4",
1204 ssdstiffenerboxshapes[2]->GetDX(),
1205 0.5*(fgkSSDStiffenerWidth
1206 - fgkSSDConnectorPosition[1]
1207 - fgkSSDConnectorWidth),
1208 0.5* fgkSSDConnectorHeight);
1209 ssdstiffenerboxshapes[4] = new TGeoBBox("SSDStiffenerBoxShape5",
1210 0.5* fgkSSDConnectorSeparation,
1211 0.5* fgkSSDConnectorWidth,
1212 0.5* fgkSSDConnectorHeight);
1213 ssdstiffenerboxshapes[5] = new TGeoBBox("SSDStiffenerBoxShape6",
1214 0.5*(fgkSSDStiffenerLength
1215 - fgkSSDConnectorPosition[0]),
1216 0.5* fgkSSDStiffenerWidth,
1217 0.5* fgkSSDConnectorHeight);
1218 TGeoVolume* ssdstiffenerbox[kstiffenerboxnumber];
1219 char ssdtiffenerboxname[30];
1220 for(Int_t i=0; i<kstiffenerboxnumber; i++){
1221 sprintf(ssdtiffenerboxname,"SSDStiffenerBox%i",i+1);
1222 ssdstiffenerbox[i] = new TGeoVolume(ssdtiffenerboxname,ssdstiffenerboxshapes[i],
1223 fSSDStiffenerMedium);
1224 ssdstiffenerbox[i]->SetLineColor(fColorStiffener);
1225 }
1226////////////////////////////
1227// Connector
1228///////////////////////////
1229 TGeoBBox* ssdconnectorshape = new TGeoBBox("SSDConnectorShape",
1230 0.5*fgkSSDConnectorLength,
1231 0.5*fgkSSDConnectorWidth,
1232 0.5*fgkSSDConnectorHeight);
1233 TGeoVolume* ssdconnector = new TGeoVolume("SSDConnector",ssdconnectorshape,
1234 fSSDStiffenerConnectorMedium);
1235 ssdconnector->SetLineColor(fColorAl);
1236 const Int_t kssdconnectornumber = 2;
1237 TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
1238 ssdconnectortrans[0] = new TGeoTranslation("SSDConnectorTrans1",
1239 - ssdstiffenerboxshapes[0]->GetDX()+fgkSSDConnectorPosition[0]
1240 - fgkSSDConnectorSeparation-1.5*fgkSSDConnectorLength,
1241 ssdstiffenerboxshapes[0]->GetDY()-fgkSSDConnectorPosition[1]
1242 - ssdconnectorshape->GetDY(),
1243 ssdstiffenerboxshapes[0]->GetDZ()+ssdconnectorshape->GetDZ());
1244 ssdconnectortrans[1] = new TGeoTranslation("SSDConnectorTrans2",
1245 - ssdstiffenerboxshapes[0]->GetDX()+fgkSSDConnectorPosition[0]
1246 - 0.5*fgkSSDConnectorLength,
1247 ssdstiffenerboxshapes[0]->GetDY()-fgkSSDConnectorPosition[1]
1248 - ssdconnectorshape->GetDY(),
1249 ssdstiffenerboxshapes[0]->GetDZ()+ssdconnectorshape->GetDZ());
1250 for(Int_t i=0; i<kssdconnectornumber; i++)
1251 ssdstiffener->AddNode(ssdconnector,i+1,ssdconnectortrans[i]);
1252//////////////////////////////////////
1253// TGeoTranslation for Stiffener Boxes
1254//////////////////////////////////////
1255 TGeoTranslation* ssdstiffenerboxtrans[kstiffenerboxnumber];
1256 ssdstiffenerboxtrans[0] = new TGeoTranslation("SSDStiffenerBoxTrans1",0.,0.,0.);
1257 ssdstiffenerboxtrans[1] = new TGeoTranslation("SSDStiffenerBoxTrans2",
1258 - (ssdstiffenerboxshapes[0]->GetDX()-ssdstiffenerboxshapes[1]->GetDX()),
1259 0.,
1260 ssdstiffenerboxshapes[0]->GetDZ()+ssdstiffenerboxshapes[1]->GetDZ());
1261 ssdstiffenerboxtrans[2] = new TGeoTranslation("SSDStiffenerBoxTrans3",
1262 - ssdstiffenerboxshapes[0]->GetDX()-ssdstiffenerboxshapes[2]->GetDX()
1263 + fgkSSDConnectorPosition[0],
1264 ssdstiffenerboxshapes[0]->GetDY()-ssdstiffenerboxshapes[2]->GetDY(),
1265 ssdstiffenerboxshapes[0]->GetDZ()+ssdstiffenerboxshapes[2]->GetDZ());
1266 ssdstiffenerboxtrans[3] = new TGeoTranslation("SSDStiffenerBoxTrans4",
1267 - ssdstiffenerboxshapes[0]->GetDX()-ssdstiffenerboxshapes[3]->GetDX()
1268 + fgkSSDConnectorPosition[0],
1269 - ssdstiffenerboxshapes[0]->GetDY()+ssdstiffenerboxshapes[3]->GetDY(),
1270 ssdstiffenerboxshapes[0]->GetDZ()+ssdstiffenerboxshapes[3]->GetDZ());
1271 ssdstiffenerboxtrans[4] = new TGeoTranslation("SSDStiffenerBoxTrans5",
1272 - ssdstiffenerboxshapes[0]->GetDX()+fgkSSDConnectorPosition[0]
1273 - 0.5*fgkSSDConnectorSeparation-2.*ssdconnectorshape->GetDX(),
1274 ssdstiffenerboxshapes[0]->GetDY()-fgkSSDConnectorPosition[1]
1275 - ssdconnectorshape->GetDY(),
1276 ssdstiffenerboxshapes[0]->GetDZ()+ssdconnectorshape->GetDZ());
1277 ssdstiffenerboxtrans[5] = new TGeoTranslation("SSDStiffenerBoxTrans6",
1278 - ssdstiffenerboxshapes[0]->GetDX()+fgkSSDConnectorPosition[0]
1279 + ssdstiffenerboxshapes[5]->GetDX(),
1280 0.,
1281 ssdstiffenerboxshapes[0]->GetDZ()+ssdstiffenerboxshapes[5]->GetDZ());
1282 for(Int_t i=0; i<kstiffenerboxnumber; i++)
1283 ssdstiffener->AddNode(ssdstiffenerbox[i],1,ssdstiffenerboxtrans[i]);
1284 TGeoCombiTrans* ssdstiffenercombitrans[kssdstiffenernumber];
1285 char ssdstiffenercombitransname[30];
1286 for(Int_t i=0; i<kssdstiffenernumber; i++){
1287 sprintf(ssdstiffenercombitransname,"SSDStiffenerCombiTrans%i",i+1);
1288 ssdstiffenercombitrans[i] = new TGeoCombiTrans(ssdstiffenercombitransname,
1289 0.,i*ssdstiffenerseparation,0.,new TGeoRotation("",180*(1-i),0.,0.));
1290 }
1291////////////////////////////
1292// Capacitor 0603-2200 nF
1293///////////////////////////
1294 const Int_t knapacitor0603number = 5;
1295 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
1296 0.5*fgkSSDCapacitor0603Length,
1297 0.5*fgkSSDCapacitor0603Width,
1298 0.5*fgkSSDCapacitor0603Height);
1299 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
1300 fSSDStiffener0603CapacitorMedium);
1301 capacitor0603->SetLineColor(fColorAl);
1302////////////////////////////
1303// Capacitor 1812-330 nF
1304///////////////////////////
1305 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
1306 0.5*fgkSSDCapacitor1812Length,
1307 0.5*fgkSSDCapacitor1812Width,
1308 0.5*fgkSSDCapacitor1812Height);
1309 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
1310 fSSDStiffener1812CapacitorMedium);
1311 capacitor1812->SetLineColor(fColorAl);
1312 TGeoTranslation* capacitor1812trans = new TGeoTranslation("Capacitor1812Trans",
1313 0.,
1314 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
1315 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],
1316 ssdstiffenerboxshapes[0]->GetDZ()+fgkSSDConnectorHeight
1317 + 0.5*fgkSSDCapacitor1812Height);
1318////////////////////////////
1319//Hybrid Wire
1320////////////////////////////
1321 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
1322 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
1323 - fgkSSDConnectorSeparation;
1324 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
1325 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
1326 Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
1327 + TMath::Power(wirey,2));
1328 Double_t wireangle = TMath::ATan(wirex/wirey);
1329 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
1330 fgkSSDWireRadius, 0.5*ssdwireradius);
1331 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
1332 fSSDStiffenerHybridWireMedium);
1333 hybridwire->SetLineColor(fColorPhynox);
1334 TGeoCombiTrans* hybridwirecombitrans[2];
1335 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
1336 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
1337 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
1338 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
1339 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
1340 ssdstiffenerboxshapes[0]->GetDZ()+fgkSSDConnectorHeight
1341 + fgkSSDWireRadius,
1342 new TGeoRotation("HybridWireRot1",0.,90.,0.));
1343 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
1344 0.,
1345 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
1346 0.,
1347 new TGeoRotation("HybridWireRot2",
1348 - wireangle*TMath::RadToDeg(),0.,0.));
1349 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
1350 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
1351 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
1352////////////////////////////
1353// Stiffener Assembly
1354///////////////////////////
1355 TGeoVolume* ssdstiffenerassembly =
1356 new TGeoVolumeAssembly("SSDStiffenerAssembly");
1357 ssdstiffenerassembly->AddNode(hybridwire,1,hybridwirematrix);
1358 for(Int_t i=0; i<kssdstiffenernumber; i++) {
1359 ssdstiffenerassembly->AddNode(ssdstiffener,i+1,ssdstiffenercombitrans[i]);
1360 for(Int_t j=1; j<knapacitor0603number+1; j++){
1361 ssdstiffenerassembly->AddNode(capacitor0603,knapacitor0603number*i+j,new TGeoTranslation("",(j-3.
1362 )/6*fgkSSDStiffenerLength,
1363 i*ssdstiffenerseparation+
1364 0.5*((i==0? 1:-1)*fgkSSDStiffenerWidth
1365 +(i==0? -1:+1)*fgkSSDCapacitor0603Width),
1366 -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
1367 }
1368 if(i==1) ssdstiffenerassembly->AddNode(capacitor1812,1,capacitor1812trans);
1369}
1370 return ssdstiffenerassembly;
1371}
1372/////////////////////////////////////////////////////////////////////////////////
1373TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth,
1374 char* side){
1375 /////////////////////////////////////////////////////////////
1376 // Method generating SSD Chip Cables
1377 /////////////////////////////////////////////////////////////
1378 const Int_t kssdchipcableslaynumber = 2;
1379 Int_t ssdchipcablescolor[2] = {fColorAl,fColorPolyhamide};
1380 Double_t ssdchipcablesradius[2];
1381 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
1382 - fgkSSDChipCablesHeight[0]
1383 - fgkSSDChipCablesHeight[1]);
1384 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
1385 Double_t ssdchipcablespiecelength = 0.5*(fgkSSDChipCablesWidth[0]
1386 - 2.*TMath::Pi()*ssdchipcablesradius[0]
1387 - ssdchipcablesradius[0]
1388 - fgkSSDChipCablesWidth[1]
1389 - fgkSSDChipCablesWidth[2]
1390 - (side=="Right" ? 0 :
1391 fgkSSDModuleStiffenerPosition[1]
1392 + TMath::Pi()*(0.5*fgkSSDSensorHeight
1393 + fgkSSDChipCablesHeight[0]
1394 + fgkSSDChipCablesHeight[1])));
1395 //////////////////////////
1396 //Box and Tube Seg Shapes
1397 //////////////////////////
1398 char* ssdchipcablesboxshapename[2*kssdchipcableslaynumber] =
1399 {"SSDChipCablesBoxLay0Shape0","SSDChipCablesBoxLay0Shape1",
1400 "SSDChipCablesBoxLay1Shape0","SSDChipCablesBoxLay1Shape1"};
1401 char* ssdchipcablestubesegshapename[2*kssdchipcableslaynumber] =
1402 {"SSDChipCablesTubeSegLay0Shape0","SSDChipCablesTubeSegLay0Shape1",
1403 "SSDChipCablesTubeSegLay1Shape0","SSDChipCablesTubeSegLay1Shape1"};
1404 TGeoBBox** ssdchipcablesboxshape[kssdchipcableslaynumber];
1405 TGeoTubeSeg** ssdchipcablestubesegshape[kssdchipcableslaynumber];
1406 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
1407 ssdchipcablesboxshape[i] = new TGeoBBox*[2];
1408 ssdchipcablestubesegshape[i] = new TGeoTubeSeg*[2+(side=="Right" ? 0 : 1)];
1409 ssdchipcablesboxshape[i][0] = new TGeoBBox(ssdchipcablesboxshapename[2*i],
1410 0.5*ssdchipcablespiecelength,
1411 0.5*fgkSSDChipCablesLength[1],
1412 0.5*fgkSSDChipCablesHeight[i]);
1413 ssdchipcablesboxshape[i][1] = new TGeoBBox(ssdchipcablesboxshapename[2*i+1],
1414 0.5*(ssdchipcablespiecelength+ssdchipcablesradius[0]
1415 + (side=="Right" ? 0. : fgkSSDModuleStiffenerPosition[1])),
1416 0.5*fgkSSDChipCablesLength[1],0.5*fgkSSDChipCablesHeight[i]);
1417 ssdchipcablestubesegshape[i][0] =
1418 new TGeoTubeSeg(ssdchipcablestubesegshapename[2*i],
1419 ssdchipcablesradius[1]-i*fgkSSDChipCablesHeight[1],
1420 ssdchipcablesradius[i],0.5*fgkSSDChipCablesLength[1],
1421 0.,180.);
1422 ssdchipcablestubesegshape[i][1] =
1423 new TGeoTubeSeg(ssdchipcablestubesegshapename[2*i+1],
1424 ssdchipcablesradius[0]+i*fgkSSDChipCablesHeight[0],
1425 ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
1426 + i*fgkSSDChipCablesHeight[1],
1427 0.5*fgkSSDChipCablesLength[1],0.,180.);
1428 if(side!="Right") ssdchipcablestubesegshape[i][2] =
1429 new TGeoTubeSeg(ssdchipcablestubesegshapename[2*i],
1430 0.5*fgkSSDSensorHeight+(1-i)*fgkSSDChipCablesHeight[1],
1431 0.5*fgkSSDSensorHeight+(1-i)*fgkSSDChipCablesHeight[0]
1432 + fgkSSDChipCablesHeight[1],
1433 0.5*fgkSSDChipCablesLength[1],0.,180.);
1434 }
1435 //////////////////////////
1436 //Box under Chip
1437 //////////////////////////
1438 char ssdunderchipcablesboxshapename[30];
1439 char ssdunderchipcablesboxname[30];
1440 char ssdunderchipcablesboxtransname[30];
1441 TGeoBBox* ssdunderchipcablesboxshape[kssdchipcableslaynumber];
1442 TGeoVolume* ssdunderchipcablesbox[kssdchipcableslaynumber];
1443 TGeoTranslation* ssdunderchipcablesboxtrans[kssdchipcableslaynumber];
1444 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
1445 sprintf(ssdunderchipcablesboxshapename,"SSDUnderChipCablesBoxShape%i",i+1);
1446 sprintf(ssdunderchipcablesboxname,"SSDUnderChipCablesBox%i",i+1);
1447 sprintf(ssdunderchipcablesboxtransname,"SSDUnderChipCablesBoxTrans%i",i+1);
1448 ssdunderchipcablesboxshape[i] =
1449 new TGeoBBox(ssdunderchipcablesboxshapename,
1450 0.5*fgkSSDChipWidth,
1451 0.5*fgkSSDChipCablesLength[1],
1452 0.5*fgkSSDChipCablesHeight[i]);
1453 ssdunderchipcablesbox[i] = new TGeoVolume(ssdunderchipcablesboxname,
1454 ssdunderchipcablesboxshape[i],
1455 (i==0?fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium));
1456 ssdunderchipcablesbox[i]->SetLineColor(ssdchipcablescolor[i]);
1457 ssdunderchipcablesboxtrans[i] =
1458 new TGeoTranslation(ssdunderchipcablesboxtransname,
1459 (side=="Right"?-1.:1.)*0.5*fgkSSDChipWidth,
1460 0.5*(fgkSSDChipCablesLength[0]-fgkSSDChipCablesLength[1])
1461 +0.5*fgkSSDChipCablesLength[1],
1462 (i==0?1.:-1.)*0.5*fgkSSDChipCablesHeight[1-i]);
1463 }
1464 //////////////////
1465 //Trapezoid Shapes
1466 //////////////////
1467 const Int_t kssdchipcablesvertexnumber = 2;
1468 const Int_t kssdchipcablestrapezoidnumber = 2;
1469 TVector3** ssdchipcablestrapezoidvertex[kssdchipcablesvertexnumber];
1470 for(Int_t i = 0; i< kssdchipcablestrapezoidnumber; i++)
1471 ssdchipcablestrapezoidvertex[i] = new TVector3*[kssdchipcablesvertexnumber];
1472 //First Shape Vertex Positioning
1473 ssdchipcablestrapezoidvertex[0][0] = new TVector3();
1474 ssdchipcablestrapezoidvertex[0][1] =
1475 new TVector3(0.5*(fgkSSDChipCablesLength[0]-fgkSSDChipCablesLength[1]));
1476 //Second Shape Vertex Positioning
1477 ssdchipcablestrapezoidvertex[1][0] =
1478 new TVector3(*ssdchipcablestrapezoidvertex[0][0]);
1479 ssdchipcablestrapezoidvertex[1][1] =
1480 new TVector3(*ssdchipcablestrapezoidvertex[0][1]);
1481 //Setting the names of shapes and volumes
1482 char* ssdchipcablestrapezoidboxshapename[kssdchipcablestrapezoidnumber] =
1483 {"SSDChipCablesTrapezoidBoxShape1","SSDChipCablesTrapezoidBoxShape2"};
1484 char* ssdchipcablestrapezoidshapename[kssdchipcablestrapezoidnumber] =
1485 {"SSDChipCablesTrapezoidShape1","SSDChipCablesTrapezoidShape2"};
1486 char* ssdchipcablestrapezoidboxname[kssdchipcablestrapezoidnumber] =
1487 {"SSDChipCablesTrapezoidBox1","SSDChipCablesTrapezoidBox2"};
1488 char* ssdhipcablestrapezoidname[kssdchipcablestrapezoidnumber] =
1489 {"SSDChipCablesTrapezoid1","SSDChipCablesTrapezoid2"};
1490 char* ssdchipcablestrapezoidassemblyname[kssdchipcablestrapezoidnumber] =
1491 {"SSDChipCablesTrapezoidAssembly1","SSDChipCablesTrapezoidAssembly2"};
1492 //Setting the Shapes
1493 TGeoBBox* ssdchipcablestrapezoidboxshape[kssdchipcablestrapezoidnumber];
1494 TGeoArb8* ssdchipcablestrapezoidshape[kssdchipcablestrapezoidnumber];
1495 //Setting the Volumes
1496 TGeoVolume* ssdchipcablestrapezoidbox[kssdchipcablestrapezoidnumber];
1497 TGeoVolume* ssdchipcablestrapezoid[kssdchipcablestrapezoidnumber];
1498 TGeoVolume* ssdchipcablestrapezoidassembly[kssdchipcablestrapezoidnumber];
1499 Double_t ssdchipcablestrapezoidwidth[kssdchipcablesvertexnumber] =
1500 {fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2],fgkSSDChipCablesWidth[1]};
1501 for(Int_t i=0; i<kssdchipcablestrapezoidnumber; i++){
1502 ssdchipcablestrapezoidboxshape[i] =
1503 new TGeoBBox(ssdchipcablestrapezoidboxshapename[i],
1504 0.5*fgkSSDChipCablesLength[1],
1505 0.5*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]),
1506 0.5*fgkSSDChipCablesHeight[i]);
1507 ssdchipcablestrapezoidshape[i] =
1508 GetTrapezoidShape(ssdchipcablestrapezoidvertex[i],
1509 ssdchipcablestrapezoidwidth,
1510 fgkSSDChipCablesHeight[i],
1511 ssdchipcablestrapezoidshapename[i]);
1512 ssdchipcablestrapezoidbox[i] =
1513 new TGeoVolume(ssdchipcablestrapezoidboxname[i],
1514 ssdchipcablestrapezoidboxshape[i],
1515 (i==0?fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium));
1516 ssdchipcablestrapezoid[i] = new TGeoVolume(ssdhipcablestrapezoidname[i],
1517 ssdchipcablestrapezoidshape[i],
1518 (i==0?fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium));
1519 ssdchipcablestrapezoidbox[i]->SetLineColor(ssdchipcablescolor[i]);
1520 ssdchipcablestrapezoid[i]->SetLineColor(ssdchipcablescolor[i]);
1521 ssdchipcablestrapezoidassembly[i] =
1522 new TGeoVolumeAssembly(ssdchipcablestrapezoidassemblyname[i]);
1523 ssdchipcablestrapezoidassembly[i]->AddNode(ssdchipcablestrapezoidbox[i],1,
1524 new TGeoTranslation(0.5*fgkSSDChipCablesLength[1],
1525 0.5*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]),0.));
1526 ssdchipcablestrapezoidassembly[i]->AddNode(ssdchipcablestrapezoid[i],0,
1527 new TGeoCombiTrans(0.,0.,0.,new TGeoRotation("",90.,180.,-90.)));
1528 ssdchipcablestrapezoidassembly[i]->AddNode(ssdchipcablestrapezoid[i],1,
1529 new TGeoTranslation(fgkSSDChipCablesLength[1],0.,0.));
1530 }
1531 /////////////////////////////
1532 //Box and Tube Seg CombiTrans
1533 /////////////////////////////
1534 TGeoTranslation* ssdchipcablesboxtrans[2*kssdchipcableslaynumber];
1535 ssdchipcablesboxtrans[0] =
1536 new TGeoTranslation("SSDChipCablesLay1Box1Trans",0.,0.,0.);
1537 ssdchipcablesboxtrans[1] =
1538 new TGeoTranslation("SSDChipCablesLay1Box2Trans",
1539 ssdchipcablesboxshape[0][1]->GetDX()
1540 - 0.5*ssdchipcablespiecelength,
1541 0.0,
1542 - 2.*ssdchipcablesradius[0]
1543 - fgkSSDChipCablesHeight[0]);
1544 ssdchipcablesboxtrans[2] = new TGeoTranslation("SSDChipCablesLay2Box1Trans",
1545 0.0,
1546 0.0,
1547 0.5*(fgkSSDChipCablesHeight[0]
1548 + fgkSSDChipCablesHeight[1]));
1549 ssdchipcablesboxtrans[3] =
1550 new TGeoTranslation("SSDChipCablesLay2Box2Trans",
1551 ssdchipcablesboxshape[1][1]->GetDX()
1552 - 0.5*ssdchipcablespiecelength,
1553 0.0,
1554 - 2.*ssdchipcablesradius[0]
1555 - 0.5*fgkSSDChipCablesHeight[1]
1556 - 1.5*fgkSSDChipCablesHeight[0]);
1557 TGeoRotation* ssdchipcablesrot[3];
1558 ssdchipcablesrot[0] = new TGeoRotation("SSDChipCablesRot1",0.,90.,0.);
1559 ssdchipcablesrot[1] = new TGeoRotation("SSDChipCablesRot2",90.,90.,-90.);
1560 ssdchipcablesrot[2] = new TGeoRotation("SSDChipCablesRot3",90.,-90.,-90.);
1561 TGeoCombiTrans* ssdchipcablestubesegcombitrans[2*(kssdchipcableslaynumber+1)];
1562// TGeoCombiTrans* SSDChipCablesTubeSegCombiTrans[2*(SSDChipCablesLayNumber+
1563// (side=="Right" ? 0 : 1))];
1564 ssdchipcablestubesegcombitrans[0] =
1565 new TGeoCombiTrans("SSDChipCablesLay1TubeSeg1CombiTrans",
1566 0.5*ssdchipcablespiecelength,
1567 0.0,
1568 ssdchipcablesradius[0]
1569 - 0.5*fgkSSDChipCablesHeight[0],
1570 new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0])));
1571 ssdchipcablestubesegcombitrans[1] =
1572 new TGeoCombiTrans("SSDChipCablesLay1TubeSeg2CombiTrans",
1573 - 0.5*ssdchipcablespiecelength,
1574 0.0,
1575 - ssdchipcablesradius[0]-0.5*fgkSSDChipCablesHeight[0],
1576 new TGeoRotation((*ssdchipcablesrot[2])*(*ssdchipcablesrot[0])));
1577 ssdchipcablestubesegcombitrans[2] =
1578 new TGeoCombiTrans("SSDChipCablesLay2TubeSeg1CombiTrans",
1579 0.5*ssdchipcablespiecelength,
1580 0.0,
1581 ssdchipcablesradius[0]-0.5*fgkSSDChipCablesHeight[0],
1582 new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0])));
1583 ssdchipcablestubesegcombitrans[3] =
1584 new TGeoCombiTrans("SSDChipCablesLay2TubeSeg2CombiTrans",
1585 - 0.5*ssdchipcablespiecelength,
1586 0.0,
1587 - ssdchipcablesradius[0]+0.5*fgkSSDChipCablesHeight[0]
1588 - fgkSSDChipCablesHeight[0],
1589 new TGeoRotation((*ssdchipcablesrot[2])*(*ssdchipcablesrot[0])));
1590 ssdchipcablestubesegcombitrans[4] =
1591 new TGeoCombiTrans("SSDChipCablesLay1TubeSeg4CombiTrans",
1592 0.5*ssdchipcablespiecelength+ssdchipcablesradius[0]
1593 + fgkSSDModuleStiffenerPosition[1],
1594 0.0,
1595 - 2.*ssdchipcablesradius[0]-0.5*fgkSSDChipCablesHeight[0]
1596 - (0.5*fgkSSDSensorHeight+fgkSSDChipCablesHeight[0]
1597 + fgkSSDChipCablesHeight[1]),
1598 new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0])));
1599 ssdchipcablestubesegcombitrans[5] =
1600 new TGeoCombiTrans("SSDChipCablesLay2TubeSeg5CombiTrans",
1601 0.5*ssdchipcablespiecelength+ssdchipcablesradius[0]
1602 + fgkSSDModuleStiffenerPosition[1],
1603 0.0,
1604 - 2.*ssdchipcablesradius[0]-0.5*fgkSSDChipCablesHeight[0]
1605 - (0.5*fgkSSDSensorHeight+fgkSSDChipCablesHeight[0]
1606 + fgkSSDChipCablesHeight[1]),
1607 new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0])));
1608 TGeoCombiTrans* ssdchipcablestrapezoidcombitrans[kssdchipcableslaynumber];
1609 ssdchipcablestrapezoidcombitrans[0] = (side=="Right" ?
1610 new TGeoCombiTrans("SSDChipCableLay1TrapezoidRightCombiTrans",
1611 0.5*ssdchipcablespiecelength+ssdchipcablestrapezoidwidth[0]
1612 + ssdchipcablesradius[0],
1613 - 0.5*fgkSSDChipCablesLength[1],
1614 - fgkSSDChipCablesHeight[0]-2.*ssdchipcablesradius[0],
1615 new TGeoRotation("",90.,0.,0.)) :
1616 new TGeoCombiTrans("SSDChipCableLay1TrapezoidLeftCombiTrans",
1617 - 2.*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2])
1618 + 0.5*ssdchipcablespiecelength+ssdchipcablestrapezoidwidth[0]
1619 + ssdchipcablesradius[0]+fgkSSDModuleStiffenerPosition[1],
1620 0.5*fgkSSDChipCablesLength[1],
1621 - 2.*(fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1])
1622 - 2.*ssdchipcablesradius[0]-fgkSSDSensorHeight,
1623 new TGeoRotation("",-90.,0.,0.)));
1624 ssdchipcablestrapezoidcombitrans[1] = (side=="Right" ?
1625 new TGeoCombiTrans("SSDChipCableLay2TrapezoidRightCombiTrans",
1626 0.5*ssdchipcablespiecelength+ssdchipcablestrapezoidwidth[0]
1627 + ssdchipcablesradius[0],
1628 - 0.5*fgkSSDChipCablesLength[1],
1629 - 0.5*(fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1])
1630 - fgkSSDChipCablesHeight[0]-2.*ssdchipcablesradius[0],
1631 new TGeoRotation("",90.,0.,0.)) :
1632 new TGeoCombiTrans("SSDChipCableLay2TrapezoidLeftCombiTrans",
1633 - 2.*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2])
1634 + 0.5*ssdchipcablespiecelength+ssdchipcablestrapezoidwidth[0]
1635 + ssdchipcablesradius[0]+fgkSSDModuleStiffenerPosition[1],
1636 0.5*fgkSSDChipCablesLength[1],-0.5*(fgkSSDChipCablesHeight[0]
1637 + fgkSSDChipCablesHeight[1])-fgkSSDChipCablesHeight[1]
1638 - fgkSSDChipCablesHeight[0]-2.*ssdchipcablesradius[0]
1639 - fgkSSDSensorHeight,new TGeoRotation("",-90.,0.,0.)));
1640 //////////////////////////
1641 //Box and Tube Seg Volumes
1642 //////////////////////////
1643 char* ssdchipcablesboxname[2*kssdchipcableslaynumber] =
1644 {"SSDChipCablesLay1Box1","SSDChipCablesLay1Box2",
1645 "SSDChipCablesLay2Box1","SSDChipCablesLay2Box2"};
1646 char* ssdchiprightcablestubesegname[2*kssdchipcableslaynumber] =
1647 {"SSDChipRightCablesLay1TubeSeg1","SSDChipRightCablesLay1TubeSeg2",
1648 "SSDChipRightCablesLay2TubeSeg1","SSDChipRightCablesLay2TubeSeg2"};
1649 char* ssdchipLeftcablestubesegname[2*kssdchipcableslaynumber] =
1650 {"SSDChipLeftCablesLay1TubeSeg1","SSDChipLeftCablesLay1TubeSeg2",
1651 "SSDChipLeftCablesLay2TubeSeg1","SSDChipLeftCablesLay2TubeSeg2"};
1652 char* ssdchipcableslayassemblyname[kssdchipcableslaynumber] =
1653 {"SSDChipCablesLay1","SSDChipCablesLay2"};
1654 TGeoVolume** ssdchipcablesbox[kssdchipcableslaynumber];
1655 TGeoVolume** ssdchipcablestubeseg[kssdchipcableslaynumber];
1656 TGeoVolume* ssdchipcableslayassembly[kssdchipcableslaynumber];
1657 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
1658 TGeoMedium* ssdchipcableslaymed =
1659 (i==0?fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
1660 ssdchipcablesbox[i] = new TGeoVolume*[2];
1661 ssdchipcablestubeseg[i] = new TGeoVolume*[2+(side=="Right" ? 0 : 1)];
1662 ssdchipcablesbox[i][0] = new TGeoVolume(ssdchipcablesboxname[2*i],
1663 ssdchipcablesboxshape[i][0],ssdchipcableslaymed);
1664 ssdchipcablesbox[i][1] = new TGeoVolume(ssdchipcablesboxname[2*i+1],
1665 ssdchipcablesboxshape[i][1],ssdchipcableslaymed);
1666 ssdchipcablestubeseg[i][0] = new TGeoVolume(ssdchiprightcablestubesegname[2*i],
1667 ssdchipcablestubesegshape[i][0],ssdchipcableslaymed);
1668 ssdchipcablestubeseg[i][1] = new TGeoVolume(ssdchiprightcablestubesegname[2*i+1],
1669 ssdchipcablestubesegshape[i][1],ssdchipcableslaymed);
1670 ssdchipcablesbox[i][0]->SetLineColor(ssdchipcablescolor[i]);
1671 ssdchipcablesbox[i][1]->SetLineColor(ssdchipcablescolor[i]);
1672 ssdchipcablestubeseg[i][0]->SetLineColor(ssdchipcablescolor[i]);
1673 ssdchipcablestubeseg[i][1]->SetLineColor(ssdchipcablescolor[i]);
1674 ssdchipcableslayassembly[i] = new TGeoVolumeAssembly(ssdchipcableslayassemblyname[i]);
1675 ssdchipcableslayassembly[i]->AddNode(ssdchipcablesbox[i][0],1,
1676 ssdchipcablesboxtrans[2*i]);
1677 ssdchipcableslayassembly[i]->AddNode(ssdchipcablesbox[i][1],1,
1678 ssdchipcablesboxtrans[2*i+1]);
1679 ssdchipcableslayassembly[i]->AddNode(ssdchipcablestubeseg[i][0],1,
1680 ssdchipcablestubesegcombitrans[2*i]);
1681 ssdchipcableslayassembly[i]->AddNode(ssdchipcablestubeseg[i][1],1,
1682 ssdchipcablestubesegcombitrans[2*i+1]);
1683 if(side!="Right"){
1684 ssdchipcablestubeseg[i][2] = new TGeoVolume(ssdchipLeftcablestubesegname[2*i],
1685 ssdchipcablestubesegshape[i][2],
1686 ssdchipcableslaymed);
1687 ssdchipcablestubeseg[i][2]->SetLineColor(ssdchipcablescolor[i]);
1688 ssdchipcableslayassembly[i]->AddNode(ssdchipcablestubeseg[i][2],1,
1689 ssdchipcablestubesegcombitrans[4+i]);
1690 }
1691 ssdchipcableslayassembly[i]->AddNode(ssdchipcablestrapezoidassembly[i],1,
1692 ssdchipcablestrapezoidcombitrans[i]);
1693 }
1694 TGeoCombiTrans* ssdchipcablescombitrans[kssdchipcableslaynumber];
1695 ssdchipcablescombitrans[0] = new TGeoCombiTrans("SSDChipCablesCombiTrans1",
1696 (side=="Right" ? -1 : 1)*0.5*ssdchipcablespiecelength,
1697 0.5*fgkSSDChipCablesLength[0],
1698 - (2.*ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0]
1699 - 0.5*fgkSSDChipCablesHeight[1]),
1700 new TGeoRotation("",(side=="Right" ? 0 : 1)*180.,0.,0.));
1701 ssdchipcablescombitrans[1] = new TGeoCombiTrans("SSDChipCablesCombiTrans2",
1702 (side=="Right" ? -1 : 1)*0.5*ssdchipcablespiecelength,
1703 0.5*fgkSSDChipCablesLength[0],
1704 - (2.*ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0]
1705 - 0.5*fgkSSDChipCablesHeight[1]),
1706 new TGeoRotation("",(side=="Right" ? 0 : 1)*180.,0.,0.));
1707 TGeoVolume* ssdchipcablesassembly =
1708 new TGeoVolumeAssembly("SSDChipCables");
1709 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
1710 ssdchipcablesassembly->AddNode(ssdchipcableslayassembly[i],1,
1711 ssdchipcablescombitrans[i]);
1712 ssdchipcablesassembly->AddNode(ssdunderchipcablesbox[i],1,ssdunderchipcablesboxtrans[i]);
1713 }
1714 return ssdchipcablesassembly;
1715}
1716/////////////////////////////////////////////////////////////////////////////////
1717TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCablesAssembly(Double_t SSDChipCablesHeigth){
1718 /////////////////////////////////////////////////////////////
1719 // Method generating SSD Chip Cables Assembly
1720 /////////////////////////////////////////////////////////////
1721 const Int_t kchipcablesnumber = 2;
1722 Double_t chipcablestransvector = fgkSSDSensorLength
1723 - 2.*fgkSSDModuleStiffenerPosition[1]
1724 - 2.*(fgkSSDStiffenerWidth
1725 - fgkSSDStiffenerToChipDist-fgkSSDChipWidth);
1726 char* ssdchipcablesname[kchipcablesnumber] = {"Right","Left"};
1727 TGeoVolume* ssdchipcables[kchipcablesnumber];
1728 TGeoVolume* ssdchipcablesassembly =
1729 new TGeoVolumeAssembly("SSDChipCablesAssembly");
1730 for(Int_t i=0; i<kchipcablesnumber; i++) ssdchipcables[i] =
1731 GetSSDChipCables(SSDChipCablesHeigth,ssdchipcablesname[i]);
1732 for(Int_t i=0; i<kchipcablesnumber; i++)
1733 for(Int_t j=0; j<fgkSSDChipNumber; j++)
1734 ssdchipcablesassembly->AddNode(ssdchipcables[i],fgkSSDChipNumber*i+j+1,
1735 new TGeoTranslation(-(ssdchipcablesname[i]=="Left" ? 1. : 0.)
1736 * chipcablestransvector,(j-0.5)*fgkSSDChipCablesLength[0]
1737 + 0.5*fgkSSDChipCablesLength[1],0.));
1738 return ssdchipcablesassembly;
1739}
1740/////////////////////////////////////////////////////////////////////////////////
1741TGeoVolume* AliITSv11GeometrySSD::GetSSDFlex(Double_t ssdflexradius, Double_t SSDFlexHeigth){
1742 /////////////////////////////////////////////////////////////
1743 // Method generating SSD Flex
1744 /////////////////////////////////////////////////////////////
1745 const Int_t kssdflexvolumenumber = 3;
1746 TGeoVolume* ssdflexvolume[kssdflexvolumenumber];
1747 ////////////////////////
1748 // Setting Display Color
1749 ////////////////////////
1750 Int_t ssdflexcolor;
1751 ssdflexcolor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
1752 TGeoMedium* ssdflexmed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fSSDAlTraceFlexMedium :
1753 fSSDKaptonFlexMedium);
1754 ////////////////////////
1755 // SSDFlexTrapezoidShape
1756 ////////////////////////
1757 const Int_t kssdflexvertexnumber = 2;
1758 Double_t ssdflexwidth[kssdflexvertexnumber] = {fgkSSDFlexWidth[1],
1759 fgkSSDFlexWidth[0]};
1760 TVector3* ssdflexvertex[kssdflexvertexnumber];
1761 ssdflexvertex[0] = new TVector3();
1762 ssdflexvertex[1] = new TVector3(fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
1763 TGeoArb8* ssdflextrapezoidshape = GetTrapezoidShape(ssdflexvertex,
1764 ssdflexwidth,SSDFlexHeigth,
1765 "SSDFlexTrapezoidShape");
1766 ssdflexvolume[0] = new TGeoVolume("SSDFlexTrapezoid",ssdflextrapezoidshape,ssdflexmed);
1767 ssdflexvolume[0]->SetLineColor(ssdflexcolor);
1768 /////////////////////////
1769 //SSDFlexTubeSeg Assembly
1770 /////////////////////////
1771 const Int_t kssdflextubesegnumber = 2;
1772 TGeoTubeSeg* ssdflextubesegshape[kssdflextubesegnumber];
1773 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1774 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1775 ssdflextubesegshape[0] = new TGeoTubeSeg("SSDFlexTubeSegShape1",
1776 ssdflexradius,ssdflexradius+SSDFlexHeigth,
1777 0.5*fgkSSDFlexWidth[0],0.,180.);
1778 ssdflextubesegshape[1] = new TGeoTubeSeg("SSDFlexTubeSegShape2",
1779 ssdflexradiusmax-ssdflexradius-SSDFlexHeigth,
1780 ssdflexradiusmax-ssdflexradius,0.5*fgkSSDFlexWidth[0],
1781 0.,2.*fgkSSDFlexAngle);
1782 TGeoRotation** ssdflextubsegrot[kssdflextubesegnumber];
1783 for(Int_t i = 0; i<kssdflextubesegnumber; i++)
1784 ssdflextubsegrot[i] = new TGeoRotation*[2];
1785 ssdflextubsegrot[0][0] = new TGeoRotation("SSDFlexTubeSeg1Rot1", 0., 90., 0.);
1786 ssdflextubsegrot[0][1] = new TGeoRotation("SSDFlexTubeSeg1Rot2",90., 90.,-90.);
1787 ssdflextubsegrot[1][0] = new TGeoRotation("SSDFlexTubeSeg2Rot1", 0.,-90., 0.);
1788 ssdflextubsegrot[1][1] = new TGeoRotation("SSDFlexTubeSeg2Rot2",90., 90.,-90.);
1789 TGeoCombiTrans* ssdflextubesegcombitrans[kssdflextubesegnumber];
1790 ssdflextubesegcombitrans[0] = new TGeoCombiTrans("SSDFlexTubeSegCombiTrans1",
1791 fgkSSDFlexLength[0],0.5*fgkSSDFlexWidth[0],
1792 ssdflexradius+0.5*SSDFlexHeigth,
1793 new TGeoRotation((*ssdflextubsegrot[0][1])
1794 * (*ssdflextubsegrot[0][0])));
1795 ssdflextubesegcombitrans[1] = new TGeoCombiTrans("SSDFlexTubeSegCombiTrans2",
1796 fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1797 0.5*fgkSSDFlexWidth[0],
1798 ssdflexradiusmax+0.5*SSDFlexHeigth+ssdflexradius,
1799 new TGeoRotation((*ssdflextubsegrot[1][1])
1800 * (*ssdflextubsegrot[1][0])));
1801 ssdflexvolume[1] = new TGeoVolumeAssembly("SSDFlexTubeSegAssembly");
1802 TGeoVolume* ssdflextubeseg[kssdflextubesegnumber];
1803 char ssdflextubesegname[30];
1804 for(Int_t i=0; i<kssdflextubesegnumber; i++){
1805 sprintf(ssdflextubesegname,"SSDFlexTubeSeg%i",i+1);
1806 ssdflextubeseg[i] = new TGeoVolume(ssdflextubesegname,ssdflextubesegshape[i],
1807 ssdflexmed);
1808 ssdflextubeseg[i]->SetLineColor(ssdflexcolor);
1809 ssdflexvolume[1]->AddNode(ssdflextubeseg[i],1,ssdflextubesegcombitrans[i]);
1810 }
1811 ///////////
1812 //Box Shape
1813 ///////////
1814 const Int_t kssdflexboxnumber = 7;
1815 Double_t ssdflexboxlength[kssdflexboxnumber];
1816 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
1817 * fgkSSDChipLength+(fgkSSDChipNumber-1)
1818 * fgkSSDChipSeparationLength
1819 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
1820 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
1821 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
1822 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
1823 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
1824 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
1825 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
1826 - ssdflexboxlength[1];
1827 ssdflexboxlength[5] = fgkSSDFlexLength[2];
1828 ssdflexboxlength[6] = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1829 * TMath::DegToRad()*ssdflexradiusmax
1830 - fgkSSDFlexLength[2]-TMath::Pi()
1831 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
1832 Double_t ssdflexboxwidth[kssdflexboxnumber];
1833 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
1834 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
1835 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
1836 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
1837 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
1838 ssdflexboxwidth[5] = fgkSSDFlexWidth[0];
1839 ssdflexboxwidth[6] = fgkSSDFlexWidth[0];
1840 TGeoBBox* ssdflexboxshape[kssdflexboxnumber+1];
1841 for(Int_t i=0; i<kssdflexboxnumber+1; i++) ssdflexboxshape[i] =
1842 (i!= kssdflexboxnumber ? new TGeoBBox("SSDFlexBoxShape",
1843 0.5*ssdflexboxlength[i],
1844 0.5*ssdflexboxwidth[i],0.5*SSDFlexHeigth) :
1845 ssdflexboxshape[2]);
1846 //////////////////////////////
1847 //SSDFlex Box Shape CombiTrans
1848 //////////////////////////////
1849 TGeoCombiTrans* ssdflexboxcombitrans[kssdflexboxnumber+1];
1850 ssdflexboxcombitrans[0] = new TGeoCombiTrans("SSDFlexBoxCombiTrans0",
1851 ssdflexvertex[1]->X()+0.5*ssdflexboxlength[0],
1852 0.5*fgkSSDFlexWidth[0],0.,0);
1853 ssdflexboxcombitrans[1] = new TGeoCombiTrans("SSDFlexBoxCombiTrans1",
1854 ssdflexvertex[1]->X()+ssdflexboxlength[0]
1855 + 0.5*ssdflexboxlength[1],
1856 fgkSSDFlexHoleWidth+0.5*ssdflexboxwidth[1],0.,0);
1857 ssdflexboxcombitrans[2] = new TGeoCombiTrans("SSDFlexBoxCombiTrans2",
1858 ssdflexvertex[1]->X()+ssdflexboxlength[0]
1859 + fgkSSDFlexHoleLength+0.5*ssdflexboxlength[2],
1860 0.5*ssdflexboxwidth[2],0.,0);
1861 ssdflexboxcombitrans[3] = new TGeoCombiTrans("SSDFlexBoxCombiTrans3",
1862 ssdflexvertex[1]->X()+ssdflexboxlength[0]
1863 + fgkSSDFlexHoleLength+ssdflexboxlength[2]
1864 + 0.5*fgkSSDFlexHoleWidth,
1865 fgkSSDFlexHoleLength+0.5*ssdflexboxwidth[3],0.,0);
1866 ssdflexboxcombitrans[4] = new TGeoCombiTrans("SSDFlexBoxCombiTrans4",
1867 ssdflexvertex[1]->X()+ssdflexboxlength[0]
1868 + ssdflexboxlength[1]+0.5*ssdflexboxlength[4],
1869 0.5*fgkSSDFlexWidth[0],0.,0);
1870 ssdflexboxcombitrans[5] = new TGeoCombiTrans("SSDFlexBoxCombiTrans5",
1871 - 0.5*fgkSSDFlexLength[2]+fgkSSDFlexLength[0],
1872 0.5*fgkSSDFlexWidth[0],
1873 2.*ssdflexradius+SSDFlexHeigth,0);
1874 ssdflexboxcombitrans[6] = new TGeoCombiTrans("SSDFlexBoxCombiTrans6",
1875 - ssdflexboxshape[6]->GetDX()
1876 + ssdflexboxshape[6]->GetDX()
1877 * TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad())
1878 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2]
1879 - (ssdflexradiusmax-ssdflexradius-0.5*SSDFlexHeigth)
1880 * TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad()),
1881 0.5*fgkSSDFlexWidth[0],ssdflexboxshape[6]->GetDX()
1882 *TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())
1883 + SSDFlexHeigth+2.*ssdflexradius+(ssdflexradiusmax
1884 - ssdflexradius-0.5*SSDFlexHeigth)
1885 * TMath::Sin(fgkSSDFlexAngle*TMath::DegToRad()),
1886 new TGeoRotation("",90.,2.*fgkSSDFlexAngle,-90.));
1887 ssdflexboxcombitrans[7] = new TGeoCombiTrans("SSDFlexBoxCombiTrans7",
1888 ssdflexvertex[1]->X()+ssdflexboxlength[0]
1889 + fgkSSDFlexHoleLength+1.5*ssdflexboxlength[2]
1890 + ssdflexboxlength[3],
1891 0.5*ssdflexboxwidth[2],0.,0);
1892 ////////////////////////////
1893 //SSDFlex Box Shape Assembly
1894 ////////////////////////////
1895 ssdflexvolume[2] = new TGeoVolumeAssembly("SSDFlexBoxAssembly");
1896 TGeoVolume* ssdflexbox[kssdflexboxnumber+1];
1897 TGeoVolume* ssdendflex = GetSSDEndFlex(ssdflexboxlength[6],SSDFlexHeigth);
1898 TGeoHMatrix* ssdendflexhmatrix = new TGeoHMatrix();
1899 TGeoRotation* ssdendflexrot = new TGeoRotation("SSDEndFlexRot",180.,0.,0);
1900 ssdendflexhmatrix->MultiplyLeft(ssdendflexrot);
1901 ssdendflexhmatrix->MultiplyLeft(ssdflexboxcombitrans[6]);
1902 char ssdflexboxname[30];
1903 for(Int_t i=0; i<kssdflexboxnumber+1; i++){
1904 sprintf(ssdflexboxname,"SSDFlexBox%i",i!=kssdflexboxnumber?i+1:7);
1905 if(i==6){ssdflexvolume[2]->AddNode(ssdendflex,1,ssdendflexhmatrix);}
1906 else{
1907 ssdflexbox[i] = new TGeoVolume(ssdflexboxname,ssdflexboxshape[i],
1908 ssdflexmed);
1909 ssdflexbox[i]->SetLineColor(ssdflexcolor);
1910 ssdflexvolume[2]->AddNode(ssdflexbox[i],1,ssdflexboxcombitrans[i]);}
1911 }
1912 //////////////////////
1913 //SSDFlex Construction
1914 //////////////////////
1915 TGeoVolume* ssdflex = new TGeoVolumeAssembly("SSDFlex");
1916 for(Int_t i =0; i<kssdflexvolumenumber; i++) ssdflex->AddNode(ssdflexvolume[i],1);
1917 return ssdflex;
1918}
1919/////////////////////////////////////////////////////////////////////////////////
1920TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(Double_t SSDEndFlexLength,
1921 Double_t SSDFlexHeigth){
1922 /////////////////////////////////////////////////////////////
1923 // Method generating SSD End Flex
1924 /////////////////////////////////////////
1925 // Setting Display Color, Media and Index
1926 /////////////////////////////////////////
1927 Int_t ssdflexcolor;
1928 ssdflexcolor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
1929 TGeoMedium* ssdflexmed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fSSDAlTraceFlexMedium :
1930 fSSDKaptonFlexMedium);
1931 ////////////////////////
1932 const Int_t kssdendflexboxnumber = 5;
1933 TGeoBBox* ssdendflexbboxshape[kssdendflexboxnumber];
1934 ssdendflexbboxshape[0] = new TGeoBBox("SSDFlexBoxShape1",
1935 0.5*SSDEndFlexLength,0.5*fgkSSDFlexWidth[0],
1936 0.5*SSDFlexHeigth);
1937 ssdendflexbboxshape[1] = new TGeoBBox("SSDFlexBoxShape2",
1938 0.5*fgkSSDEndFlexCompLength[1],
1939 0.5*(fgkSSDEndFlexCompWidth[0]-fgkSSDFlexWidth[0])/2,
1940 0.5*SSDFlexHeigth);
1941 ssdendflexbboxshape[2] = new TGeoBBox("SSDFlexBoxShape3",
1942 0.5*fgkSSDEndFlexCompLength[2],
1943 0.5*(fgkSSDEndFlexCompWidth[1]-fgkSSDFlexWidth[0])/2,
1944 0.5*SSDFlexHeigth);
1945 ssdendflexbboxshape[3] = new TGeoBBox("SSDFlexBoxShape4",
1946 0.5*fgkSSDEndFlexCompLength[3],
1947 0.5*(fgkSSDEndFlexCompWidth[0]-fgkSSDFlexWidth[0])/2,
1948 0.5*SSDFlexHeigth);
1949 ssdendflexbboxshape[4] = new TGeoBBox("SSDFlexBoxShape5",
1950 0.5*(fgkSSDEndFlexCompLength[4]+fgkSSDEndFlexCompLength[5]),
1951 0.25*(fgkSSDEndFlexCompWidth[2]-fgkSSDFlexWidth[0])/2,
1952 0.5*SSDFlexHeigth);
1953 TGeoVolume* ssdendflexbbox[kssdendflexboxnumber];
1954 char ssdendflexbboxname[30];
1955 for(Int_t i=0; i<kssdendflexboxnumber; i++){
1956 sprintf(ssdendflexbboxname,"SSDEndFlexBBox%i",i+1);
1957 ssdendflexbbox[i] = new TGeoVolume(ssdendflexbboxname,
1958 ssdendflexbboxshape[i],
1959 ssdflexmed);
1960 ssdendflexbbox[i]->SetLineColor(ssdflexcolor);
1961 }
1962 TGeoVolume* ssdendflex = new TGeoVolumeAssembly("SSDEndFlex");
1963 Double_t partialsumlength = 0.;
1964 for(Int_t i=0; i<kssdendflexboxnumber+1; i++) partialsumlength += fgkSSDEndFlexCompLength[i];
1965 Double_t referencelength = SSDEndFlexLength-partialsumlength;
1966 ssdendflex->AddNode(ssdendflexbbox[0],1);
1967 ssdendflex->AddNode(ssdendflexbbox[1],1,new TGeoTranslation(
1968 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
1969 + 0.5*fgkSSDEndFlexCompLength[1],
1970 0.5*fgkSSDFlexWidth[0]+ssdendflexbboxshape[1]->GetDY(),
1971 0.));
1972 ssdendflex->AddNode(ssdendflexbbox[1],2,new TGeoTranslation(
1973 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
1974 + 0.5*fgkSSDEndFlexCompLength[1],
1975 - 0.5*fgkSSDFlexWidth[0]-ssdendflexbboxshape[1]->GetDY(),
1976 0.));
1977 ssdendflex->AddNode(ssdendflexbbox[2],1,new TGeoTranslation(
1978 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
1979 + fgkSSDEndFlexCompLength[1]+0.5*fgkSSDEndFlexCompLength[2],
1980 + 0.5*fgkSSDFlexWidth[0]+ssdendflexbboxshape[2]->GetDY(),
1981 0.));
1982 ssdendflex->AddNode(ssdendflexbbox[2],2,new TGeoTranslation(
1983 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
1984 + fgkSSDEndFlexCompLength[1]+0.5*fgkSSDEndFlexCompLength[2],
1985 - 0.5*fgkSSDFlexWidth[0]-ssdendflexbboxshape[2]->GetDY(),
1986 0.));
1987 ssdendflex->AddNode(ssdendflexbbox[3],1,new TGeoTranslation(
1988 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
1989 + fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
1990 + 0.5*fgkSSDEndFlexCompLength[3],
1991 + 0.5*fgkSSDFlexWidth[0]+ssdendflexbboxshape[3]->GetDY(),
1992 0.));
1993 ssdendflex->AddNode(ssdendflexbbox[3],2,new TGeoTranslation(
1994 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
1995 + fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
1996 + 0.5*fgkSSDEndFlexCompLength[3],
1997 - 0.5*fgkSSDFlexWidth[0]-ssdendflexbboxshape[3]->GetDY(),
1998 0.));
1999 ssdendflex->AddNode(ssdendflexbbox[4],1,new TGeoTranslation(
2000 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
2001 + fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
2002 + fgkSSDEndFlexCompLength[3]+0.5*(fgkSSDEndFlexCompLength[4]+fgkSSDEndFlexCompLength[5]),
2003 + 0.5*fgkSSDFlexWidth[0]+ssdendflexbboxshape[4]->GetDY(),
2004 0.));
2005 ssdendflex->AddNode(ssdendflexbbox[4],2,new TGeoTranslation(
2006 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
2007 + fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
2008 + fgkSSDEndFlexCompLength[3]+0.5*(fgkSSDEndFlexCompLength[4]
2009 + fgkSSDEndFlexCompLength[5]),
2010 - 0.5*fgkSSDFlexWidth[0]-ssdendflexbboxshape[4]->GetDY(),
2011 0.));
2012 return ssdendflex;
2013}
2014/////////////////////////////////////////////////////////////////////////////////
2015TGeoVolume* AliITSv11GeometrySSD::GetSSDFlexAssembly(){
2016 /////////////////////////////////////////////////////////////
2017 // Method generating SSD Flex Assembly
2018 /////////////////////////////////////////////////////////////
2019 TGeoVolume* ssdflexassembly = new TGeoVolumeAssembly("SSDFlexAssembly");
2020 const Int_t kssdflexlayernumber = 4;
2021 Double_t ssdflexheight[kssdflexlayernumber];
2022 Double_t ssdflexradius[kssdflexlayernumber];
2023 TGeoTranslation* ssdflextrans[kssdflexlayernumber];
2024 for(Int_t i=0; i<kssdflexlayernumber; i++){
2025 ssdflexheight[i] = (i%2==0 ? fgkSSDFlexHeight[0] : fgkSSDFlexHeight[1]);
2026 ssdflexradius[i] = (i==0 ? fgkSSDStiffenerHeight : ssdflexradius[i-1]
2027 + ssdflexheight[i-1]);
2028 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(ssdflexheight[0]
2029 + ssdflexheight[1]));
2030 ssdflexassembly->AddNode(GetSSDFlex(ssdflexradius[i],ssdflexheight[i]),i+1,
2031 ssdflextrans[i]);
2032 }
2033 return ssdflexassembly;
2034}
2035/////////////////////////////////////////////////////////////////////////////////
2036TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlockAssembly(){
2037 /////////////////////////////////////////////////////////////
2038 // Method generating SSD Cooling Block Assembly
2039 /////////////////////////////////////////////////////////////
2040 const Int_t kssdcoolingblocktransnumber = 2;
2041 Double_t ssdcoolingblocktransvector[kssdcoolingblocktransnumber] =
2042 {fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength,
2043 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
2044 - fgkSSDCoolingBlockWidth};
2045 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock();
2046 TGeoVolume* ssdcoolingblockassembly =
2047 new TGeoVolumeAssembly("SSDCoolingBlockAssembly");
2048 for(Int_t i=0; i<kssdcoolingblocktransnumber; i++)
2049 for(Int_t j=0; j<kssdcoolingblocktransnumber; j++)
2050 ssdcoolingblockassembly->AddNode(ssdcoolingblock,
2051 kssdcoolingblocktransnumber*i+j+1,
2052 new TGeoTranslation(i*ssdcoolingblocktransvector[0],
2053 j*ssdcoolingblocktransvector[1],0.));
2054 return ssdcoolingblockassembly;
2055}
2056/////////////////////////////////////////////////////////////////////////////////
2057TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(){
2058 /////////////////////////////////////////////////////////////
2059 // Method generating SSD Cooling Block
2060 /////////////////////////////////////////////////////////////
2061 // Center Cooling Block Hole
2062 ////////////////////////////
2063 Double_t coolingblockholeangle = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
2064 /fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
2065 Double_t coolingblockholewidth = fgkSSDCoolingBlockWidth;
2066 new TGeoTubeSeg("CoolingBlockHoleShape",
2067 0.,
2068 fgkSSDCoolingBlockHoleRadius[0],
2069 0.5*coolingblockholewidth,
2070 180.-coolingblockholeangle,360.+coolingblockholeangle);
2071 TVector3* coolingblockholevertex[3];
2072 coolingblockholevertex[0] = new TVector3();
2073 coolingblockholevertex[1] = new TVector3(fgkSSDCoolingBlockHoleRadius[0]
2074 * TMath::Cos((90.-coolingblockholeangle)*TMath::DegToRad()),
2075 fgkSSDCoolingBlockHoleRadius[0]
2076 * TMath::Sin((90.-coolingblockholeangle)*TMath::DegToRad()));
2077 coolingblockholevertex[2] = new TVector3(coolingblockholevertex[1]->X(),
2078 - coolingblockholevertex[1]->Y());
2079 GetTriangleShape(coolingblockholevertex,
2080 coolingblockholewidth,"CoolingBlockTriangleHoleShape");
2081 TGeoRotation* coolingblockholerot =
2082 new TGeoRotation("CoolingBlockHoleRot",90,0.,0.);
2083 coolingblockholerot->RegisterYourself();
2084 new TGeoCompositeShape("CoolingTubeHoleShape",
2085 "CoolingBlockTriangleHoleShape:CoolingBlockHoleRot+"
2086 "CoolingBlockHoleShape");
2087 ///////////////////////////
2088 // Cooling Block Trapezoids
2089 ///////////////////////////
2090 const Int_t kvertexnumber = 4;
2091 const Int_t ktrapezoidnumber = 2;
2092 TVector3** coolingblocktrapezoidvertex[ktrapezoidnumber];
2093 for(Int_t i = 0; i<ktrapezoidnumber; i++) coolingblocktrapezoidvertex[i] =
2094 new TVector3*[kvertexnumber];
2095 Double_t coolingblockcomponentheight = fgkSSDCoolingBlockHeight[0]
2096 - fgkSSDCoolingBlockHoleCenter
2097 - fgkSSDCoolingBlockHoleRadius[0]
2098 * TMath::Sin(coolingblockholeangle*TMath::DegToRad());
2099 Double_t coolingblocktrapezoidlength[ktrapezoidnumber] =
2100 { fgkSSDCoolingBlockLength,
2101 0.5*(fgkSSDCoolingBlockLength-2.
2102 * (fgkSSDCoolingBlockHoleLength[1]
2103 - fgkSSDCoolingBlockHoleRadius[1])
2104 - fgkSSDCoolingBlockHoleLength[0])};
2105 Double_t coolingblocktrapezoidheigth[ktrapezoidnumber] =
2106 { fgkSSDCoolingBlockHeight[0]-coolingblockcomponentheight
2107 - fgkSSDCoolingBlockHeight[1]-fgkSSDCoolingBlockHeight[2]
2108 - fgkSSDCoolingBlockHoleRadius[1],
2109 coolingblockcomponentheight};
2110 Double_t coolingblocktrapezoidwidth[ktrapezoidnumber] =
2111 {fgkSSDCoolingBlockWidth,fgkSSDCoolingBlockWidth};
2112 //////////////////////////
2113 //Vertex Positioning Shape
2114 //////////////////////////
2115 coolingblocktrapezoidvertex[0][0] = new TVector3();
2116 coolingblocktrapezoidvertex[0][1] = new TVector3(coolingblocktrapezoidlength[0]);
2117 coolingblocktrapezoidvertex[0][2] = new TVector3(
2118 0.5*(coolingblocktrapezoidvertex[0][1]->X()
2119 - 2.*coolingblocktrapezoidlength[1]
2120 - fgkSSDCoolingBlockHoleLength[0]));
2121 coolingblocktrapezoidvertex[0][3] =
2122 new TVector3(coolingblocktrapezoidvertex[0][1]->X()
2123 - coolingblocktrapezoidvertex[0][2]->X());
2124 coolingblocktrapezoidvertex[1][0] = new TVector3();
2125 coolingblocktrapezoidvertex[1][1] = new TVector3(coolingblocktrapezoidlength[1]);
2126 coolingblocktrapezoidvertex[1][2] =
2127 new TVector3(coolingblocktrapezoidheigth[1]
2128 / coolingblocktrapezoidheigth[0]
2129 * coolingblocktrapezoidvertex[0][2]->X());
2130 coolingblocktrapezoidvertex[1][3] =
2131 new TVector3(coolingblocktrapezoidvertex[1][1]->X());
2132 char* coolingblocktrapezoidshapename[ktrapezoidnumber] =
2133 {"CoolingBlockTrapezoidShape0","CoolingBlockTrapezoidShape1"};
2134 TGeoArb8* coolingblocktrapezoidshape[ktrapezoidnumber];
2135 for(Int_t i = 0; i< ktrapezoidnumber; i++) coolingblocktrapezoidshape[i] =
2136 GetArbShape(coolingblocktrapezoidvertex[i],
2137 coolingblocktrapezoidwidth,
2138 coolingblocktrapezoidheigth[i],
2139 coolingblocktrapezoidshapename[i]);
2140 TGeoTranslation* coolingblocktrapezoidtrans =
2141 new TGeoTranslation("CoolingBlockTrapezoidTrans",
2142 coolingblocktrapezoidvertex[0][2]->X(),
2143 0.0,
2144 0.5*(coolingblocktrapezoidheigth[0]
2145 + coolingblocktrapezoidheigth[1]));
2146 coolingblocktrapezoidtrans->RegisterYourself();
2147 TGeoCombiTrans* coolingblocktrapezoidcombitrans =
2148 new TGeoCombiTrans("CoolingBlockTrapezoidCombiTrans",
2149 coolingblocktrapezoidvertex[0][3]->X(),
2150 fgkSSDCoolingBlockWidth,
2151 0.5*(coolingblocktrapezoidheigth[0]
2152 + coolingblocktrapezoidheigth[1]),
2153 new TGeoRotation("",180.,0.,0.));
2154 coolingblocktrapezoidcombitrans->RegisterYourself();
2155 new TGeoCompositeShape("CoolingBlockTrapezoidCompositeShape",
2156 "CoolingBlockTrapezoidShape0+CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidTrans+"
2157 "CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidCombiTrans");
2158 /////////////////////////////
2159 // Cooling Block Boxes Shapes
2160 /////////////////////////////
2161 const Int_t kboxnumber = 3;
2162 TGeoBBox* coolingblockboxshape[kboxnumber];
2163 coolingblockboxshape[0] = new TGeoBBox("CoolingBlockBoxShape0",
2164 0.5*fgkSSDCoolingBlockLength,
2165 0.5*fgkSSDCoolingBlockWidth,
2166 0.5*fgkSSDCoolingBlockHoleRadius[1]);
2167 coolingblockboxshape[1] = new TGeoBBox("CoolingBlockBoxShape1",
2168 0.5*(fgkSSDCoolingBlockLength
2169 - 2.*fgkSSDCoolingBlockHoleLength[1]),
2170 0.5*fgkSSDCoolingBlockWidth,
2171 0.5*fgkSSDCoolingBlockHeight[2]);
2172 coolingblockboxshape[2] = new TGeoBBox("CoolingBlockBoxShape2",
2173 0.5*fgkSSDCoolingBlockLength,
2174 0.5*fgkSSDCoolingBlockWidth,
2175 0.5*fgkSSDCoolingBlockHeight[1]);
2176 TGeoTranslation* coolingblockboxtrans[kboxnumber-1];
2177 coolingblockboxtrans[0] = new TGeoTranslation("CoolingBlockBoxTrans0",0.,0.,
2178 0.5*(fgkSSDCoolingBlockHeight[1]
2179 + fgkSSDCoolingBlockHoleRadius[1])
2180 + fgkSSDCoolingBlockHeight[2]);
2181 coolingblockboxtrans[1] = new TGeoTranslation("CoolingBlockBoxTrans1",
2182 0.0,
2183 0.0,
2184 0.5*(fgkSSDCoolingBlockHeight[1]
2185 + fgkSSDCoolingBlockHeight[2]));
2186 for(Int_t i=0; i<kboxnumber-1; i++) coolingblockboxtrans[i]->RegisterYourself();
2187 new TGeoCompositeShape("CoolingBlockBoxCompositeShape",
2188 "CoolingBlockBoxShape0:CoolingBlockBoxTrans0+"
2189 "CoolingBlockBoxShape1:CoolingBlockBoxTrans1+CoolingBlockBoxShape2");
2190 ///////////////////////
2191 // Cooling Block Shape
2192 //////////////////////
2193 TGeoCombiTrans* coolingtubeholeshapecombitrans =
2194 new TGeoCombiTrans("CoolingTubeHoleShapeCombiTrans",
2195 0.5*fgkSSDCoolingBlockLength,
2196 0.5*fgkSSDCoolingBlockWidth,
2197 fgkSSDCoolingBlockHoleCenter,
2198 new TGeoRotation("",0.,90.,0.));
2199 coolingtubeholeshapecombitrans->RegisterYourself();
2200 TGeoTranslation* coolingblocktrapezoidcompositeshapetrans =
2201 new TGeoTranslation("CoolingBlockTrapezoidCompositeShapeTrans",
2202 0.0,
2203 0.0,
2204 0.5*coolingblocktrapezoidheigth[0]+fgkSSDCoolingBlockHeight[1]+
2205 fgkSSDCoolingBlockHeight[2]+fgkSSDCoolingBlockHoleRadius[1]);
2206 coolingblocktrapezoidcompositeshapetrans->RegisterYourself();
2207 TGeoTranslation* coolingblockboxcompositeshapetrans =
2208 new TGeoTranslation("CoolingBlockBoxCompositeShapeTrans",
2209 0.5*fgkSSDCoolingBlockLength,
2210 0.5*fgkSSDCoolingBlockWidth,
2211 0.5*fgkSSDCoolingBlockHeight[1]);
2212 coolingblockboxcompositeshapetrans->RegisterYourself();
2213 TGeoCompositeShape* ssdoolingblockshape =
2214 new TGeoCompositeShape("SSDCoolingBlockShape",
2215 "CoolingBlockBoxCompositeShape:CoolingBlockBoxCompositeShapeTrans+"
2216 "CoolingBlockTrapezoidCompositeShape:CoolingBlockTrapezoidCompositeShapeTrans-"
2217 "CoolingTubeHoleShape:CoolingTubeHoleShapeCombiTrans");
2218 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
2219 ssdoolingblockshape,fSSDAlCoolBlockMedium);
2220 return ssdcoolingblock;
2221}
2222/////////////////////////////////////////////////////////////////////////////////
2223TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
2224 /////////////////////////////////////////////////////////////
2225 // Method generating SSD Carbon Fiber Junction
2226 /////////////////////////////////////////////////////////////
2227 const Int_t kvertexnumber = 4;
2228 TVector3* vertex[kvertexnumber];
2229 vertex[0] = new TVector3();
2230 vertex[1] = new TVector3(fgkCarbonFiberJunctionLength,0.);
2231 vertex[2] = new TVector3(fgkCarbonFiberJunctionLength
2232 - fgkCarbonFiberJunctionEdge[1]
2233 * TMath::Cos(fgkCarbonFiberJunctionAngle[1]*TMath::DegToRad()),
2234 fgkCarbonFiberJunctionEdge[1]*TMath::Sin(fgkCarbonFiberJunctionAngle[1]
2235 * TMath::DegToRad()));
2236 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2237 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]*TMath::DegToRad()),
2238 fgkCarbonFiberJunctionEdge[0]
2239 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]*TMath::DegToRad()));
2240 TGeoArb8* carbonfiberjunctionshapepiece =
2241 new TGeoArb8("CarbonFiberJunctionShapePiece",0.5*width);
2242 //////////////////////////////////
2243 //Setting the vertices in TGeoArb8
2244 //////////////////////////////////
2245 for(Int_t i = 0; i<2*kvertexnumber; i++)
2246 carbonfiberjunctionshapepiece->SetVertex(i,
2247 vertex[(i < kvertexnumber ? i: i-kvertexnumber)]->X(),
2248 vertex[(i < kvertexnumber ? i : i-kvertexnumber)]->Y());
2249 TGeoRotation* carbonfiberjunctionrot =
2250 new TGeoRotation("CarbonFiberJunctionRot",
2251 180.,
2252 180.,
2253 180-2.*fgkCarbonFiberJunctionAngle[0]);
2254 TGeoVolume* carbonfiberjunctionpiece =
2255 new TGeoVolume("CarbonFiberJunctionPiece",
2256 carbonfiberjunctionshapepiece,fSSDCarbonFiberMedium);
2257 TGeoVolume* carbonfiberjunction =
2258 new TGeoVolumeAssembly("CarbonFiberJunction");
2259 carbonfiberjunctionpiece->SetLineColor(fColorCarbonFiber);
2260 carbonfiberjunction->AddNode(carbonfiberjunctionpiece,1);
2261 carbonfiberjunction->AddNode(carbonfiberjunctionpiece,2,carbonfiberjunctionrot);
2262 return carbonfiberjunction;
2263}
2264/////////////////////////////////////////////////////////////////////////////////
2265TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunctionAssembly(){
2266 /////////////////////////////////////////////////////////////
2267 // Method generating SSD Carbon Fiber Junction Assembly
2268 /////////////////////////////////////////////////////////////
2269 SetCarbonFiberJunctionCombiTransMatrix();
2270 TGeoVolume* carbonfiberjunctionassembly =
2271 new TGeoVolumeAssembly("CarbonFiberJunctionAssembly");
2272 TGeoVolume* carbonfiberjunction =
2273 GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
2274 for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber;i++)
2275 carbonfiberjunctionassembly->AddNode(carbonfiberjunction,i+1,
2276 fCarbonFiberJunctionCombiTransMatrix[i]);
2277 return carbonfiberjunctionassembly;
2278}
2279/////////////////////////////////////////////////////////////////////////////////
2280TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
2281 /////////////////////////////////////////////////////////////
2282 // Method returning a List containing pointers to Ladder Cable Volumes
2283 /////////////////////////////////////////////////////////////
2284 const Int_t kladdercablesegmentnumber = 2;
2285 /////////////////////////////////////////
2286 // LadderSegmentBBox Volume
2287 /////////////////////////////////////////
2288 TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
2289 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
2290 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
2291 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
2292 new TGeoBBox(laddercablesegmentbboxshapename[i],
2293 0.5*fgkSSDFlexWidth[0],
2294 0.5*fgkSSDLadderCableWidth,
2295 0.5*fgkSSDFlexHeight[i]);
2296 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
2297 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
2298 TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
2299 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
2300 laddercablesegmentbbox[i] =
2301 new TGeoVolume(laddercablesegmentbboxname[i],
2302 laddercablesegmentbboxshape[i],
2303 (i==0?fSSDAlTraceLadderCableMedium:
2304 fSSDKaptonLadderCableMedium));
2305 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
2306 fColorPolyhamide);
2307 }
2308 TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
2309 laddercablesegmentbboxtrans[0] =
2310 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
2311 0.5*fgkSSDFlexWidth[0],
2312 0.5*fgkSSDLadderCableWidth,
2313 0.5*fgkSSDFlexHeight[0]);
2314 laddercablesegmentbboxtrans[1] =
2315 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
2316 0.5*fgkSSDFlexWidth[0],
2317 0.5*fgkSSDLadderCableWidth,
2318 fgkSSDFlexHeight[0]
2319 +0.5*fgkSSDFlexHeight[1]);
2320 TGeoVolume* laddercablesegmentbboxassembly =
2321 new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
2322 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
2323 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
2324 laddercablesegmentbboxtrans[i]);
2325/////////////////////////////////////////
2326// LadderSegmentArb8 Volume
2327/////////////////////////////////////////
2328 const Int_t kvertexnumber = 4;
2329 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
2330 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
2331 new TVector3*[kvertexnumber];
2332//Shape Vertex Positioning
2333 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
2334 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
2335 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
2336 i*fgkSSDFlexHeight[0]);
2337 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
2338 + fgkSSDFlexHeight[1]
2339 + i*fgkSSDFlexHeight[0]);
2340 laddercablesegmentvertexposition[i][3] =
2341 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
2342 laddercablesegmentvertexposition[i][2]->Y());
2343 }
2344 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
2345 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
2346 char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
2347 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
2348 TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
2349 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
2350 GetArbShape(laddercablesegmentvertexposition[i],
2351 laddercablesegmentwidth[i],
2352 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
2353 laddercablesegmentarbshapename[i]);
2354 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
2355 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
2356 TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
2357 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
2358 laddercablesegmentarb[i] =
2359 new TGeoVolume(laddercablesegmentarbname[i],
2360 laddercablesegmentarbshape[i],
2361 (i==0?fSSDAlTraceLadderCableMedium:
2362 fSSDKaptonLadderCableMedium));
2363 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
2364 fColorPolyhamide);
2365}
2366 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
2367 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
2368 90.,90,-90.);
2369 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
2370 0.,90.,0.);
2371 TGeoCombiTrans* laddercablesegmentarbcombitrans =
2372 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
2373 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
2374 + fgkSSDFlexWidth[0],0.,0.,
2375 new TGeoRotation((*laddercablesegmentarbrot[1])
2376 *(*laddercablesegmentarbrot[0])));
2377 TGeoVolume* laddercablesegmentarbassembly =
2378 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
2379 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
2380 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
2381 laddercablesegmentarbcombitrans);
2382/////////////////////////////////////////
2383// End Ladder Cable Volume
2384/////////////////////////////////////////
2385 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
2386 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
2387 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
2388 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
2389 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
2390 0.5*ssdendladdercablelength,
2391 0.5*fgkSSDLadderCableWidth,
2392 0.5*fgkSSDFlexHeight[i]);
2393 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
2394 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
2395 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
2396 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
2397 ladderendcablesegmentbbox[i] =
2398 new TGeoVolume(ladderendcablesegmentbboxname[i],
2399 ladderendcablesegmentbboxshape[i],
2400 (i==0?fSSDAlTraceLadderCableMedium:
2401 fSSDKaptonLadderCableMedium));
2402 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
2403 fColorPolyhamide);
2404 }
2405 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
2406 ladderendcablesegmentbboxtrans[0] =
2407 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
2408 0.5*ssdendladdercablelength,
2409 0.5*fgkSSDLadderCableWidth,
2410 0.5*fgkSSDFlexHeight[0]);
2411 ladderendcablesegmentbboxtrans[1] =
2412 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
2413 0.5*ssdendladdercablelength,
2414 0.5*fgkSSDLadderCableWidth,
2415 fgkSSDFlexHeight[0]
2416 +0.5*fgkSSDFlexHeight[1]);
2417 TGeoVolume* ladderendcablesegmentbboxassembly =
2418 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
2419 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
2420 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
2421 ladderendcablesegmentbboxtrans[i]);
2422/////////////////////////////////////////
2423 TList* laddercablesegmentlist = new TList();
2424 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
2425 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
2426 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
2427 return laddercablesegmentlist;
2428 }
2429/////////////////////////////////////////////////////////////////////////////////
2430TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
2431 /////////////////////////////////////////////////////////////
2432 // Method generating Ladder Cable Volumes Assemblies
2433 /////////////////////////////////////////////////////////////
2434 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
2435 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
2436 for(Int_t i=0; i<n; i++){
2437 TGeoTranslation* laddercabletrans = new TGeoTranslation(
2438 i*(fgkCarbonFiberJunctionWidth),
2439 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
2440 i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
2441 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
2442 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
2443 }
2444 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
2445 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
2446 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
2447 (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
2448 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
2449 return laddercable;
2450}
2451/////////////////////////////////////////////////////////////////////////////////
2452TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
2453 /////////////////////////////////////////////////////////////
2454 // Method generating Ladder Cable Volumes Assembly
2455 /////////////////////////////////////////////////////////////
2456 TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
2457 char laddercabletransname[30];
2458 for(Int_t i=0; i<n; i++){
2459 sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
2460 laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
2461 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
2462 }
2463 return laddercableassembly;
2464}
2465/////////////////////////////////////////////////////////////////////////////////
2466TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
2467 /////////////////////////////////////////////////////////////
2468 // Method generating Ladder Cable List Assemblies
2469 /////////////////////////////////////////////////////////////
2470 const Int_t kladdercableassemblynumber = 2;
2471 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
2472 TGeoVolume* ladderCable[kladdercableassemblynumber];
2473 char laddercableassemblyname[30];
2474 TList* laddercableassemblylist = new TList();
2475 for(Int_t i=0; i<kladdercableassemblynumber; i++){
2476 sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
2477 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
2478 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
2479 new TGeoCombiTrans((n-1)
2480 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
2481 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
2482 0.,new TGeoRotation("",180,0.,0.)));
2483 laddercableassemblylist->Add(ladderCable[i]);
2484}
2485 return laddercableassemblylist;
2486}
2487/////////////////////////////////////////////////////////////////////////////////
2488TList* AliITSv11GeometrySSD::GetEndLadderCarbonFiberJunctionAssembly(){
2489 /////////////////////////////////////////////////////////////
2490 // Method generating the End Ladder Carbon Fiber Junction Assembly
2491 /////////////////////////////////////////////////////////////
2492 const Int_t kendlabbercarbonfiberjunctionumber = 2;
2493 TGeoVolume* endladdercarbonfiberjunctionassembly[kendlabbercarbonfiberjunctionumber];
2494 endladdercarbonfiberjunctionassembly[0] =
2495 new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly1");
2496 endladdercarbonfiberjunctionassembly[1] =
2497 new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly2");
2498 TGeoVolume** endladdercarbonfiberjunction[kendlabbercarbonfiberjunctionumber];
2499 for(Int_t i=0; i<kendlabbercarbonfiberjunctionumber; i++)
2500 endladdercarbonfiberjunction[i] = new TGeoVolume*[2];
2501 for(Int_t i=0; i<kendlabbercarbonfiberjunctionumber; i++){
2502 endladdercarbonfiberjunction[i][0] =
2503 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
2504 endladdercarbonfiberjunction[i][1] =
2505 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
2506 }
2507 TList* endladdercarbonfiberjunctionlist = new TList();
2508 for(Int_t i=0; i<kendlabbercarbonfiberjunctionumber; i++){
2509 SetEndLadderCarbonFiberJunctionCombiTransMatrix(i);
2510 for(Int_t j=0; j<fgkCarbonFiberJunctionCombiTransNumber; j++)
2511 endladdercarbonfiberjunctionassembly[i]->AddNode(j==2 ?
2512 endladdercarbonfiberjunction[i][1] :
2513 endladdercarbonfiberjunction[i][0],
2514 j+1,fEndLadderCarbonFiberJunctionCombiTransMatrix[j]);
2515 endladdercarbonfiberjunctionlist->Add(endladdercarbonfiberjunctionassembly[i]);
2516 }
2517 return endladdercarbonfiberjunctionlist;
2518}
2519////////////////////////////////////////////////////////////////////////////////
2520TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberSupport(){
2521 /////////////////////////////////////////////////////////////
2522 // Method generating the Carbon Fiber Support
2523 /////////////////////////////////////////////////////////////
2524 const Int_t kvertexnumber = 4;
2525 const Int_t kshapesnumber = 2;
2526 TVector3** vertexposition[kshapesnumber];
2527 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
2528 Double_t carbonfibersupportxaxisEdgeproj =
2529 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2530 * TMath::DegToRad());
2531 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
2532 / fgkCarbonFiberSupportXAxisLength);
2533 /////////////////////
2534 //Vertex Positioning
2535 ////////////////////
2536 vertexposition[0][0] = new TVector3();
2537 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
2538 fgkCarbonFiberSupportYAxisLength);
2539 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
2540 carbonfibersupportxaxisEdgeproj
2541 * TMath::Tan(theta));
2542 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
2543 - carbonfibersupportxaxisEdgeproj,
2544 fgkCarbonFiberSupportYAxisLength
2545 - vertexposition[0][2]->Y());
2546 ////////////////////////////////////////////////////
2547 //Setting the parameters for Isometry Transformation
2548 ////////////////////////////////////////////////////
2549 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
2550 + fgkCarbonFiberSupportTopEdgeDist[0]
2551 + fgkCarbonFiberSupportWidth);
2552 Double_t* param = new Double_t[4];
2553 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
2554 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
2555 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
2556 (GetReflection(vertexposition[0][j],param))->Y());
2557 char* carbonfibersupportshapename[kshapesnumber] =
2558 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
2559 TGeoArb8* carbonfibersupportshape[kshapesnumber];
2560 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
2561 Double_t carbonfibersupportheight =
2562 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
2563 *TMath::DegToRad());
2564 for(Int_t i = 0; i< kshapesnumber; i++) carbonfibersupportshape[i] =
2565 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
2566 carbonfibersupportshapename[i],i==0 ? 1: -1);
2567 /////////////////////////////////////
2568 //Setting Translations and Rotations:
2569 /////////////////////////////////////
2570 TGeoTranslation* carbonfibersupporttrans =
2571 new TGeoTranslation("CarbonFiberSupportTrans",
2572 0.0,0.0,0.5*carbonfibersupportheight);
2573 carbonfibersupporttrans->RegisterYourself();
2574 TGeoRotation* carbonfibercompshaperot[2];
2575 carbonfibercompshaperot[0] = new TGeoRotation("CarbonFiberCompShapeRot1",
2576 0.0,180.0,0.0);
2577 carbonfibercompshaperot[1] = new TGeoRotation("CarbonFiberCompShapeRot2",
2578 90.,-fgkCarbonFiberTriangleAngle,-90.);
2579 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
2580 * TMath::Cos(fgkCarbonFiberTriangleAngle
2581 * TMath::DegToRad()),0.,-fgkCarbonFiberTriangleLength
2582 * TMath::Sin(fgkCarbonFiberTriangleAngle
2583 * TMath::DegToRad())};
2584 TGeoCombiTrans* carbonfibersupportcombitrans =
2585 new TGeoCombiTrans("CarbonFiberSupportCombiTrans",
2586 transvector[0],2.*symmetryplaneposition
2587 + transvector[1],transvector[2],
2588 new TGeoRotation((*carbonfibercompshaperot[1])
2589 * (*carbonfibercompshaperot[0])));
2590 carbonfibersupportcombitrans->RegisterYourself();
2591////////////////////////////////////////////////////////////////////////////////
2592 TGeoCompositeShape* carbonfibersupportcompshape =
2593 new TGeoCompositeShape("CarbonFiberSupportCompShape",
2594 "CarbonFiberSupportShape1:CarbonFiberSupportTrans+"
2595 "CarbonFiberSupportShape2:CarbonFiberSupportTrans");
2596 TGeoVolume* carbonfibersupport = new TGeoVolume("CarbonFiberSupport",
2597 carbonfibersupportcompshape,fSSDCarbonFiberMedium);
2598 carbonfibersupport->SetLineColor(fColorCarbonFiber);
2599 TGeoVolume* carbonfibersupportassembly =
2600 new TGeoVolumeAssembly("CarbonFiberSupportAssembly");
2601 carbonfibersupportassembly->AddNode(carbonfibersupport,1);
2602 carbonfibersupportassembly->AddNode(carbonfibersupport,2,
2603 carbonfibersupportcombitrans);
2604 return carbonfibersupportassembly;
2605}
2606////////////////////////////////////////////////////////////////////////////////
2607TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberLowerSupport(Int_t ikind, Bool_t EndLadder){
2608 /////////////////////////////////////////////////////////////
2609 // Method generating the Carbon Fiber Lower Support
2610 /////////////////////////////////////////////////////////////
2611 const Int_t kvertexnumber = 4;
2612 const Int_t kshapesnumber = 2;
2613 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
2614 fgkCarbonFiberLowerSupportWidth};
2615 TVector3** vertexposition[kshapesnumber];
2616 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2617 new TVector3*[kvertexnumber];
2618 //First Shape Vertex Positioning
2619 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2620 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2621 - fgkCarbonFiberLowerSupportLowerLenght);
2622 vertexposition[0][2] = new TVector3();
2623 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2624 //Second Shape Vertex Positioning
2625 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2626 - fgkCarbonFiberLowerSupportVolumePosition[0])
2627 / fgkCarbonFiberTriangleLength);
2628 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2629 vertexposition[0][0]->X()*TMath::Tan(theta)
2630 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2631 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2632 vertexposition[0][1]->X()*TMath::Tan(theta)
2633 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2634 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2635 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2636 fgkCarbonFiberLowerSupportVolumePosition[1]);
2637 char* carbonfiberlowersupportname[kshapesnumber] =
2638 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
2639 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2640 for(Int_t i = 0; i< kshapesnumber; i++) carbonfiberlowersupportshape[i] =
2641 GetArbShape(vertexposition[i],width,
2642 fgkCarbonFiberLowerSupportHeight,
2643 carbonfiberlowersupportname[i]);
2644 ///////////////////////////////////////////////////////
2645 TGeoTranslation* carbonfiberlowersupporttrans[kshapesnumber];
2646 carbonfiberlowersupporttrans[0] =
2647 new TGeoTranslation("CarbonFiberLowerSupportTrans1",
2648 0.0,
2649 vertexposition[1][3]->Y()+vertexposition[1][2]->Y(),
2650 0.0);
2651 carbonfiberlowersupporttrans[1] =
2652 new TGeoTranslation("CarbonFiberLowerSupportTrans2",
2653 0.0,
2654 - vertexposition[1][3]->Y()-vertexposition[1][2]->Y(),
2655 0.0);
2656 for(Int_t i = 0; i< kshapesnumber; i++)
2657 carbonfiberlowersupporttrans[i]->RegisterYourself();
2658 ///////////////////////////////////////////////////////
2659 TGeoCompositeShape* carbonfiberlowersupportcompshape;
2660 if(EndLadder==false)
2661 carbonfiberlowersupportcompshape =
2662 new TGeoCompositeShape("CarbonFiberLowerSupportCompShape",
2663 "CarbonFiberLowerSupportShape2+"
2664 "CarbonFiberLowerSupportShape1:CarbonFiberLowerSupportTrans1");
2665 else
2666 if(ikind==0)
2667 carbonfiberlowersupportcompshape =
2668 (TGeoCompositeShape*)carbonfiberlowersupportshape[0];
2669 else
2670 carbonfiberlowersupportcompshape =
2671 new TGeoCompositeShape("CarbonFiberLowerSupportCompShape",
2672 "CarbonFiberLowerSupportShape1+"
2673 "CarbonFiberLowerSupportShape1:CarbonFiberLowerSupportTrans1");
2674 TGeoVolume* carbonfiberlowersupport = new TGeoVolume("CarbonFiberLowerSupport",
2675 carbonfiberlowersupportcompshape,fSSDCarbonFiberMedium);
2676 carbonfiberlowersupport->SetLineColor(fColorCarbonFiber);
2677 return carbonfiberlowersupport;
2678}
2679////////////////////////////////////////////////////////////////////////////////
2680TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberAssemblySupport(){
2681 /////////////////////////////////////////////////////////////
2682 // Method generating the Carbon Fiber Assembly Support
2683 /////////////////////////////////////////////////////////////
2684 SetCarbonFiberAssemblyCombiTransMatrix();
2685 TGeoVolume* carbonfiberassemblysupport =
2686 new TGeoVolumeAssembly("CarbonFiberAssembly");
2687 TGeoVolume* carbonfiberassemblyvolumes[fgkCarbonFiberAssemblyCombiTransNumber];
2688 carbonfiberassemblyvolumes[0] = GetCarbonFiberJunctionAssembly();
2689 carbonfiberassemblyvolumes[1] = GetCarbonFiberSupport();
2690 carbonfiberassemblyvolumes[2] = GetCarbonFiberLowerSupport();
2691 for(Int_t i=0; i<fgkCarbonFiberAssemblyCombiTransNumber;i++)
2692 carbonfiberassemblysupport->AddNode(carbonfiberassemblyvolumes[i],1,
2693 fCarbonFiberAssemblyCombiTransMatrix[i]);
2694 return carbonfiberassemblysupport;
2695}
2696////////////////////////////////////////////////////////////////////////////////
2697TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(){
2698 /////////////////////////////////////////////////////////////
2699 // Method generating the Cooling Tube Support
2700 /////////////////////////////////////////////////////////////
2701 const Int_t kvertexnumber = 3;
2702 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2703 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2704 new TGeoTubeSeg("CoolingTubeSegShape",0.0,
2705 fgkCoolingTubeSupportRmax,
2706 0.5*fgkCoolingTubeSupportWidth,phi,
2707 360-phi);
2708 new TGeoTube("CoolingTubeHoleShape",0.0,
2709 fgkCoolingTubeSupportRmin,
2710 0.5*fgkCoolingTubeSupportWidth);
2711 TVector3* vertexposition[kvertexnumber];
2712 ///////////////////////////
2713 //Shape Vertex Positioning
2714 ///////////////////////////
2715 vertexposition[0] = new TVector3();
2716 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax
2717 * TMath::Cos(phi*TMath::DegToRad()),
2718 fgkCoolingTubeSupportRmax
2719 * TMath::Sin(phi*TMath::DegToRad()));
2720 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2721 - vertexposition[1]->Y());
2722 GetTriangleShape(vertexposition,
2723 fgkCoolingTubeSupportWidth,
2724 "CoolingTubeTriangleShape");
2725 Double_t* boxorigin = new Double_t[3];
2726 Double_t boxlength = fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax
2727 - vertexposition[1]->X();
2728 boxorigin[0] = vertexposition[1]->X()+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2729 new TGeoBBox("CoolingTubeBoxShape",0.5*boxlength,
2730 0.5*fgkCoolingTubeSupportHeight,
2731 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2732 TGeoCompositeShape* coolingtubesupportshape =
2733 new TGeoCompositeShape("CoolingTubeSupportShape",
2734 "(CoolingTubeSegShape+CoolingTubeTriangleShape"
2735 "+CoolingTubeBoxShape)-CoolingTubeHoleShape");
2736 TGeoVolume* coolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2737 coolingtubesupportshape,fSSDTubeHolderMedium);
2738 return coolingtubesupport;
2739}
2740////////////////////////////////////////////////////////////////////////////////
2741TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupportAssembly(){
2742 /////////////////////////////////////////////////////////////
2743 // Method generating the Cooling Tube Support Assembly
2744 /////////////////////////////////////////////////////////////
2745 TGeoVolume* coolingtubesupportassembly =
2746 new TGeoVolumeAssembly("CoolingTubeSupportAssembly");
2747 TGeoVolume* coolingtubesupport = GetCoolingTubeSupport();
2748 SetCoolingTubeSupportCombiTransMatrix();
2749 for(Int_t i=0; i<fgkCoolingTubeSupportCombiTransNumber;i++)
2750 coolingtubesupportassembly->AddNode(coolingtubesupport,i+1,
2751 fCoolingTubeSupportCombiTransMatrix[i]);
2752 return coolingtubesupportassembly;
2753}
2754////////////////////////////////////////////////////////////////////////////////
2755TGeoVolume* AliITSv11GeometrySSD::GetCoolingTube() const{
2756 /////////////////////////////////////////////////////////////
2757 // Method generating the Cooling Tube
2758 /////////////////////////////////////////////////////////////
2759 TGeoVolume* coolingtubeassembly = new TGeoVolumeAssembly("CoolingTubeAssembly");
2760 TGeoTube *coolingtubeshape = new TGeoTube("CoolingTubeShape", fgkCoolingTubeRmin,
2761 fgkCoolingTubeRmax, fgkCoolingTubeLength/2.0);
2762 TGeoVolume* coolingtube = new TGeoVolume("CoolingTube",
2763 coolingtubeshape,fSSDCoolingTubePhynox);
2764 TGeoTube *coolingtubeinteriorshape = new TGeoTube("CoolingTubeInteriorShape",
2765 0, fgkCoolingTubeRmin,
2766 fgkCoolingTubeLength/2.0);
2767 TGeoVolume *coolingtubeinterior = new TGeoVolume("CoolingTubeInterior",
2768 coolingtubeinteriorshape,fSSDCoolingTubeWater);
2769 coolingtubeassembly->AddNode(coolingtube,1);
2770 coolingtubeassembly->AddNode(coolingtubeinterior,2);
2771 return coolingtubeassembly;
2772}
2773////////////////////////////////////////////////////////////////////////////////
2774TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeAssembly(){
2775 /////////////////////////////////////////////////////////////
2776 // Method generating the Cooling Tube Assembly
2777 /////////////////////////////////////////////////////////////
2778 TGeoVolume* coolingtubeassembly = new TGeoVolumeAssembly("CoolingTubeAssembly");
2779 TGeoVolume* coolingtube = GetCoolingTube();
2780 SetCoolingTubeCombiTransMatrix();
2781 for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber;i++)
2782 coolingtubeassembly->AddNode(coolingtube,i+1,fCoolingTubeTransMatrix[i]);
2783 return coolingtubeassembly;
2784}
2785////////////////////////////////////////////////////////////////////////////////
2786TGeoVolume* AliITSv11GeometrySSD::GetLadderSegment(Int_t iChipCablesHeight){
2787 /////////////////////////////////////////////////////////////
2788 // Method generating the basic Ladder Segment element which will be replicated
2789 /////////////////////////////////////////////////////////////
2790 TGeoVolume*laddersegment = new TGeoVolumeAssembly("LadderSegment");
2791 TGeoVolume* laddersegmentvolumes[fgkLadderSegmentCombiTransNumber];
2792 laddersegmentvolumes[0] = GetCarbonFiberAssemblySupport();
2793 laddersegmentvolumes[1] = GetSSDModule(iChipCablesHeight);
2794 laddersegmentvolumes[2] = GetSSDSensorSupportAssembly(iChipCablesHeight);
2795 laddersegmentvolumes[3] = GetCoolingTubeSupportAssembly();
2796 laddersegmentvolumes[4] = GetCoolingTubeAssembly();
2797 SetLadderSegmentCombiTransMatrix();
2798 for(Int_t i=0; i<fgkLadderSegmentCombiTransNumber; i++)
2799 laddersegment->AddNode(laddersegmentvolumes[i],1,
2800 fLadderSegmentCombiTransMatrix[i]);
2801 return laddersegment;
2802 }
2803////////////////////////////////////////////////////////////////////////////////
2804TList* AliITSv11GeometrySSD::GetEndLadderSegment(){
2805 /////////////////////////////////////////////////////////////
2806 // Method generating the Terminal Ladder Segment
2807 /////////////////////////////////////////////////////////////
2808 const Int_t kendladdersegmentnumber = 2;
2809 TList* endladdercarbonfiberjunctionlist = GetEndLadderCarbonFiberJunctionAssembly();
2810 TGeoVolume* endladdersegment[kendladdersegmentnumber];
2811 endladdersegment[0] = new TGeoVolumeAssembly("EndLadderSegment1");
2812 endladdersegment[1] = new TGeoVolumeAssembly("EndLadderSegment2");
2813 TGeoVolume** laddersegmentvolumes[kendladdersegmentnumber];
2814 const Int_t kladdersegmentvolumenumber = 4;
2815 for(Int_t i=0; i<kendladdersegmentnumber; i++) laddersegmentvolumes[i] =
2816 new TGeoVolume*[kladdersegmentvolumenumber];
2817 laddersegmentvolumes[0][0] = (TGeoVolume*)endladdercarbonfiberjunctionlist->At(0);
2818 laddersegmentvolumes[0][1] = GetCarbonFiberSupport();
2819 laddersegmentvolumes[0][2] = GetSSDMountingBlock();
2820 laddersegmentvolumes[0][3] = GetCarbonFiberLowerSupport(0,true);
2821 laddersegmentvolumes[1][0] = (TGeoVolume*)endladdercarbonfiberjunctionlist->At(1);
2822 laddersegmentvolumes[1][1] = laddersegmentvolumes[0][1];
2823 laddersegmentvolumes[1][2] = laddersegmentvolumes[0][2];
2824 laddersegmentvolumes[1][3] = GetCarbonFiberLowerSupport(1,true);
2825 TList* endladdersegmentlist = new TList();
2826 for(Int_t i=0; i<kendladdersegmentnumber; i++){
2827 SetEndLadderSegmentCombiTransMatrix(i);
2828 for(Int_t j=0; j<kladdersegmentvolumenumber; j++)
2829 endladdersegment[i]->AddNode(laddersegmentvolumes[i][j],1,
2830 fEndLadderSegmentCombiTransMatrix[j]);
2831 endladdersegmentlist->Add(endladdersegment[i]);
2832 }
2833 return endladdersegmentlist;
2834}
2835////////////////////////////////////////////////////////////////////////////////
2836TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
2837 /////////////////////////////////////////////////////////////
2838 // Method generating the Mounting Block
2839 /////////////////////////////////////////////////////////////
2840 // Mounting Block Boxes Shapes
2841 ///////////////////////////////////////
2842 const Int_t kmountingblockboxnumber = 3;
2843 TGeoBBox* mountingblockboxshape[kmountingblockboxnumber];
2844 mountingblockboxshape[0] = new TGeoBBox("MountingBlockBoxShape0",
2845 0.25*(fgkSSDMountingBlockLength[0]
2846 - fgkSSDMountingBlockLength[1]),
2847 0.5*fgkSSDMountingBlockWidth,
2848 0.5*fgkSSDMountingBlockHeight[0]);
2849 mountingblockboxshape[1] = new TGeoBBox("MountingBlockBoxShape1",
2850 0.25*(fgkSSDMountingBlockLength[1]
2851 - fgkSSDMountingBlockLength[2]),
2852 0.5*fgkSSDMountingBlockWidth,
2853 0.5*(fgkSSDMountingBlockHeight[1]
2854 - fgkSSDMountingBlockHeight[3]));
2855 mountingblockboxshape[2] = new TGeoBBox("MountingBlockBoxShape2",
2856 0.5*fgkSSDMountingBlockLength[2],
2857 0.5*fgkSSDMountingBlockWidth,
2858 0.5*(fgkSSDMountingBlockHeight[2]
2859 - fgkSSDMountingBlockHeight[3]));
2860 TGeoTranslation* mountingblockboxtrans[kmountingblockboxnumber+2];
2861 mountingblockboxtrans[0] = new TGeoTranslation("MountingBlockBoxTrans0",0.,0.,0.);
2862 mountingblockboxtrans[1] = new TGeoTranslation("MountingBlockBoxTrans1",
2863 mountingblockboxshape[0]->GetDX()
2864 + mountingblockboxshape[1]->GetDX(),
2865 0.0,
2866 mountingblockboxshape[1]->GetDZ()
2867 - mountingblockboxshape[0]->GetDZ()
2868 + fgkSSDMountingBlockHeight[3]);
2869 mountingblockboxtrans[2] = new TGeoTranslation("MountingBlockBoxTrans2",
2870 mountingblockboxshape[0]->GetDX()
2871 + 2.*mountingblockboxshape[1]->GetDX()
2872 + mountingblockboxshape[2]->GetDX(),
2873 0.0,
2874 mountingblockboxshape[2]->GetDZ()
2875 - mountingblockboxshape[0]->GetDZ()
2876 + fgkSSDMountingBlockHeight[3]);
2877 mountingblockboxtrans[3] = new TGeoTranslation("MountingBlockBoxTrans3",
2878 mountingblockboxshape[0]->GetDX()
2879 + mountingblockboxshape[1]->GetDX()
2880 + 2.*(mountingblockboxshape[1]->GetDX()
2881 + mountingblockboxshape[2]->GetDX()),
2882 0.0,
2883 mountingblockboxshape[1]->GetDZ()
2884 - mountingblockboxshape[0]->GetDZ()
2885 + fgkSSDMountingBlockHeight[3]);
2886 mountingblockboxtrans[4] = new TGeoTranslation("MountingBlockBoxTrans4",
2887 2.*(mountingblockboxshape[0]->GetDX()
2888 + 2.*mountingblockboxshape[1]->GetDX()
2889 + mountingblockboxshape[2]->GetDX()),
2890 0.0,
2891 0.0);
2892 for(Int_t i=0; i<kmountingblockboxnumber+2; i++)
2893 mountingblockboxtrans[i]->RegisterYourself();
2894 ///////////////////////////////////////
2895 // Mounting Block Trapezoid Hole Shapes
2896 ///////////////////////////////////////
2897 const Int_t kholetrapezoidvertexnumber = 4;
2898 TVector3* holetrapezoidvertex[kholetrapezoidvertexnumber];
2899 holetrapezoidvertex[0] = new TVector3();
2900 holetrapezoidvertex[1] = new TVector3(fgkSSDMountingBlockHoleTrapezoidHeight);
2901 holetrapezoidvertex[2] = new TVector3(*holetrapezoidvertex[0]);
2902 holetrapezoidvertex[3] = new TVector3(*holetrapezoidvertex[1]);
2903 Double_t holetrapezoidwidth[2] = {fgkSSDMountingBlockHoleTrapezoidUpBasis
2904 + 2.*mountingblockboxshape[1]->GetDX()
2905 * TMath::Tan(fgkSSDMountingBlockHoleTrapezoidAngle
2906 * TMath::DegToRad()),
2907 fgkSSDMountingBlockHoleTrapezoidUpBasis};
2908 GetArbShape(holetrapezoidvertex,
2909 holetrapezoidwidth,
2910 2.*mountingblockboxshape[1]->GetDX(),
2911 "HoleTrapezoidShape");
2912 TGeoRotation* holetrapezoidshaperot[2];
2913 holetrapezoidshaperot[0] = new TGeoRotation("HoleTrapezoidShapeRot0",
2914 90.,-90.,-90.);
2915 holetrapezoidshaperot[1] = new TGeoRotation("HoleTrapezoidShapeRot1",
2916 -180.,0.,0.);
2917 TGeoCombiTrans* holetrapezoidshapecombitrans =
2918 new TGeoCombiTrans("HoleTrapezoidShapeCombiTrans",
2919 mountingblockboxshape[0]->GetDX()
2920 + 3.*mountingblockboxshape[1]->GetDX()
2921 + 2.*mountingblockboxshape[2]->GetDX(),
2922 0.5*fgkSSDMountingBlockWidth,
2923 - fgkSSDMountingBlockHoleTrapezoidHeight
2924 + 2.*mountingblockboxshape[1]->GetDZ()
2925 - mountingblockboxshape[0]->GetDZ()
2926 + fgkSSDMountingBlockHeight[3],
2927 new TGeoRotation((*holetrapezoidshaperot[1])
2928 * (*holetrapezoidshaperot[0])));
2929 holetrapezoidshapecombitrans->RegisterYourself();
2930 ///////////////////////////////////
2931 // Mounting Block Screw Hole Shapes
2932 ///////////////////////////////////
2933 const Int_t kmountingblocktubenumber = 2;
2934 TGeoTube* mountingblocktubeshape[kmountingblocktubenumber];
2935 mountingblocktubeshape[0] = new TGeoTube("MountingBlockTubeShape0",0.0,
2936 fgkSSDMountingBlockHoleRadius,
2937 mountingblockboxshape[0]->GetDZ());
2938 mountingblocktubeshape[1] = new TGeoTube("MountingBlockTubeShape1",0.0,
2939 fgkSSDMountingBlockHoleRadius,
2940 mountingblockboxshape[2]->GetDZ());
2941 TGeoTranslation* mountingblocktubetrans[2*kmountingblocktubenumber];
2942 mountingblocktubetrans[0] = new TGeoTranslation("MountingBlockTubeTrans0",
2943 - 0.5*(fgkSSDMountingBlockLength[0]
2944 - fgkSSDMountingBlockHoleTubeLength[0]),
2945 0.5*fgkSSDMountingBlockWidth
2946 - fgkSSDMountingBlockHoleTubeWidth[0],0.);
2947 mountingblocktubetrans[1] = new TGeoTranslation("MountingBlockTubeTrans1",
2948 - 0.5*(fgkSSDMountingBlockLength[0]
2949 - fgkSSDMountingBlockHoleTubeLength[0])
2950 + fgkSSDMountingBlockHoleTubeLength[0],
2951 - 0.5*fgkSSDMountingBlockWidth
2952 + fgkSSDMountingBlockHoleTubeWidth[0],
2953 0.);
2954 mountingblocktubetrans[2] = new TGeoTranslation("MountingBlockTubeTrans2",
2955 - mountingblockboxshape[0]->GetDX()
2956 + 0.5*fgkSSDMountingBlockLength[0]
2957 - fgkSSDMountingBlockHoleTubeLength[1],
2958 0.5*fgkSSDMountingBlockWidth
2959 - fgkSSDMountingBlockHoleTubeWidth[0],
2960 mountingblockboxshape[2]->GetDZ()
2961 - mountingblockboxshape[0]->GetDZ()
2962 + fgkSSDMountingBlockHeight[3]);
2963 mountingblocktubetrans[3] = new TGeoTranslation("MountingBlockTubeTrans3",
2964 - mountingblockboxshape[0]->GetDX()
2965 + 0.5*fgkSSDMountingBlockLength[0],
2966 - 0.5*fgkSSDMountingBlockWidth
2967 + fgkSSDMountingBlockHoleTubeWidth[1],
2968 mountingblockboxshape[2]->GetDZ()
2969 - mountingblockboxshape[0]->GetDZ()
2970 + fgkSSDMountingBlockHeight[3]);
2971 for(Int_t i=0; i<2*kmountingblocktubenumber; i++)
2972 mountingblocktubetrans[i]->RegisterYourself();
2973 new TGeoCompositeShape("MountingBlockMainShape",
2974 "MountingBlockBoxShape0:MountingBlockBoxTrans0+"
2975 "MountingBlockBoxShape1:MountingBlockBoxTrans1+"
2976 "MountingBlockBoxShape2:MountingBlockBoxTrans2+"
2977 "MountingBlockBoxShape1:MountingBlockBoxTrans3+"
2978 "MountingBlockBoxShape0:MountingBlockBoxTrans4");
2979 ////////////////////////////////////////////
2980 // Mounting Block Screw Composite Hole Shapes
2981 ////////////////////////////////////////////
2982 const Int_t kmountingblockholetubesegnumber = 4;
2983 new TGeoTubeSeg("MountingBlockHoleTubeSegShape",
2984 0.0,
2985 fgkSSDMountingBlockScrewHoleRadius[0],
2986 0.5*fgkSSDMountingBlockScrewHoleHeigth,-90.,180.);
2987 TGeoCombiTrans* mountingblockholetubesegcombitrans[kmountingblockholetubesegnumber];
2988 char* mountingblockholetubesegcombitransname[kmountingblockholetubesegnumber] =
2989 { "MountingBlockHoleTubeSegCombiTrans0",
2990 "MountingBlockHoleTubeSegCombiTrans1",
2991 "MountingBlockHoleTubeSegCombiTrans2",
2992 "MountingBlockHoleTubeSegCombiTrans3"};
2993 for(Int_t i=0; i<kmountingblockholetubesegnumber; i++){
2994 mountingblockholetubesegcombitrans[i] =
2995 new TGeoCombiTrans(mountingblockholetubesegcombitransname[i],
2996 0.5*fgkSSDMountingBlockScrewHoleEdge*TMath::Sqrt(2)
2997 * TMath::Cos(45*(2*i+1)*TMath::DegToRad()),
2998 0.5*fgkSSDMountingBlockScrewHoleEdge*TMath::Sqrt(2)
2999 * TMath::Sin(45*(2*i+1)*TMath::DegToRad()),
3000 0.0,
3001 new TGeoRotation("",90.*i,0.,0.));
3002 mountingblockholetubesegcombitrans[i]->RegisterYourself();
3003 }
3004 TGeoBBox* mountingblockholeboxshape =
3005 new TGeoBBox("MountingBlockHoleBoxShape",
3006 0.5*fgkSSDMountingBlockScrewHoleEdge,
3007 0.5*fgkSSDMountingBlockScrewHoleEdge,
3008 0.5*fgkSSDMountingBlockScrewHoleHeigth);
3009 TGeoCompositeShape* mountingblockscrewhole[2];
3010 mountingblockscrewhole[0] =
3011 new TGeoCompositeShape("MountingBlockScrewHole0",
3012 "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans0+"
3013 "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans1+"
3014 "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans2+"
3015 "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans3+"
3016 "MountingBlockHoleBoxShape");
3017 new TGeoTubeSeg("MountingBlockLowerHoleTubeSegShape",
3018 0.0,
3019 fgkSSDMountingBlockScrewHoleRadius[1],
3020 0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
3021 - fgkSSDMountingBlockScrewHoleHeigth
3022 - fgkSSDMountingBlockHeight[3]),0.,90.);
3023 TGeoCombiTrans* mountingblocklowerholetubesegcombitrans[kmountingblockholetubesegnumber];
3024 char* mountingblocklowerholetubesegcombitransname[kmountingblockholetubesegnumber] =
3025 { "MountingBlockLowerHoleTubeSegCombiTrans0",
3026 "MountingBlockLowerHoleTubeSegCombiTrans1",
3027 "MountingBlockLowerHoleTubeSegCombiTrans2",
3028 "MountingBlockLowerHoleTubeSegCombiTrans3"};
3029 for(Int_t i=0; i<kmountingblockholetubesegnumber; i++){
3030 mountingblocklowerholetubesegcombitrans[i] =
3031 new TGeoCombiTrans(mountingblocklowerholetubesegcombitransname[i],
3032 0.5*(fgkSSDMountingBlockScrewHoleEdge
3033 - 2.*fgkSSDMountingBlockScrewHoleRadius[1])
3034 * TMath::Sqrt(2)*TMath::Cos(45*(2*i+1)*TMath::DegToRad()),
3035 0.5*(fgkSSDMountingBlockScrewHoleEdge
3036 - 2.0*fgkSSDMountingBlockScrewHoleRadius[1])
3037 * TMath::Sqrt(2)*TMath::Sin(45*(2*i+1)*TMath::DegToRad()),0.,
3038 new TGeoRotation("",90.*i,0.,0.));
3039 mountingblocklowerholetubesegcombitrans[i]->RegisterYourself();
3040 }
3041 Double_t fgkSSDMountingBlockLowerScrewHoleEdge = fgkSSDMountingBlockScrewHoleEdge
3042 - 2.*fgkSSDMountingBlockScrewHoleRadius[1];
3043 TGeoBBox* mountingblocklowerholeboxshape[2];
3044 mountingblocklowerholeboxshape[0] =
3045 new TGeoBBox("MountingBlockLowerHoleBoxShape0",
3046 0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
3047 0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
3048 0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
3049 - fgkSSDMountingBlockScrewHoleHeigth
3050 - fgkSSDMountingBlockHeight[3]));
3051 mountingblocklowerholeboxshape[1] =
3052 new TGeoBBox("MountingBlockLowerHoleBoxShape1",
3053 0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
3054 0.5*fgkSSDMountingBlockScrewHoleRadius[1],
3055 0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
3056 - fgkSSDMountingBlockScrewHoleHeigth
3057 - fgkSSDMountingBlockHeight[3]));
3058 TGeoCombiTrans* mountingblocklowerholeBoxcombitrans[kmountingblockholetubesegnumber];
3059 char* mountingBlockLowerHoleBoxCombiTransName[kmountingblockholetubesegnumber] =
3060 { "MountingBlockLowerHoleBoxCombiTrans0",
3061 "MountingBlockLowerHoleBoxCombiTrans1",
3062 "MountingBlockLowerHoleBoxCombiTrans2",
3063 "MountingBlockLowerHoleBoxCombiTrans3"};
3064 for(Int_t i=0; i<kmountingblockholetubesegnumber; i++){
3065 mountingblocklowerholeBoxcombitrans[i] =
3066 new TGeoCombiTrans(mountingBlockLowerHoleBoxCombiTransName[i],
3067 0.5*(fgkSSDMountingBlockLowerScrewHoleEdge
3068 + fgkSSDMountingBlockScrewHoleRadius[1])
3069 * TMath::Cos(90*(i+1)*TMath::DegToRad()),
3070 0.5*(fgkSSDMountingBlockLowerScrewHoleEdge
3071 + fgkSSDMountingBlockScrewHoleRadius[1])
3072 * TMath::Sin(90*(i+1)*TMath::DegToRad()),0.,
3073 new TGeoRotation("",90.*i,0.,0.));
3074 mountingblocklowerholeBoxcombitrans[i]->RegisterYourself();
3075 }
3076 mountingblockscrewhole[1] = new TGeoCompositeShape("MountingBlockScrewHole1",
3077 "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans0+"
3078 "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans1+"
3079 "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans2+"
3080 "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans3+"
3081 "MountingBlockLowerHoleBoxShape0+"
3082 "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans0+"
3083 "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans1+"
3084 "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans2+"
3085 "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans3");
3086 TGeoTranslation* mountingblockscrewhole1trans =
3087 new TGeoTranslation("MountingBlockScrewHole1Trans",0.,0.,
3088 - mountingblocklowerholeboxshape[0]->GetDZ()
3089 - mountingblockholeboxshape->GetDZ());
3090 mountingblockscrewhole1trans->RegisterYourself();
3091 new TGeoCompositeShape("MountingBlockHole",
3092 "MountingBlockScrewHole0+MountingBlockScrewHole1:MountingBlockScrewHole1Trans");
3093 TGeoTranslation* mountingblockholetrans = new TGeoTranslation("MountingBlockHoleTrans",
3094 0.5*fgkSSDMountingBlockLength[0]
3095 - mountingblockboxshape[0]->GetDZ(),
3096 0.0,
3097 2.*mountingblockboxshape[2]->GetDZ()
3098 - mountingblockboxshape[0]->GetDZ()
3099 + fgkSSDMountingBlockHeight[3]
3100 - mountingblockholeboxshape->GetDZ());
3101 mountingblockholetrans->RegisterYourself();
3102 TGeoCompositeShape* mountingblockshape = new TGeoCompositeShape("MountingBlockShape",
3103 "MountingBlockMainShape-(MountingBlockTubeShape0:MountingBlockTubeTrans0+"
3104 "MountingBlockTubeShape0:MountingBlockTubeTrans1+"
3105 "MountingBlockTubeShape1:MountingBlockTubeTrans2+"
3106 "MountingBlockTubeShape1:MountingBlockTubeTrans3+"
3107 "HoleTrapezoidShape:HoleTrapezoidShapeCombiTrans+"
3108 "MountingBlockHole:MountingBlockHoleTrans)");
3109 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
3110 mountingblockshape,fSSDMountingBlockMedium);
3111 return ssdmountingblock;
3112}
3113////////////////////////////////////////////////////////////////////////////////
3114TGeoVolume* AliITSv11GeometrySSD::GetLadder(Int_t iLayer){
3115 /////////////////////////////////////////////////////////////
3116 // Method generating the Layer5 or Layer6 Ladder
3117 /////////////////////////////////////////////////////////////
3118 TGeoVolume* ladder = new TGeoVolumeAssembly(iLayer==5 ? "ITSssdLay5Ladd"
3119 : "ITSssdLay6Ladd");
3120 TGeoVolume* laddersegment[2];
3121 laddersegment[0] = GetLadderSegment(0);
3122 laddersegment[1] = GetLadderSegment(1);
3123 TList* endladdersegmentlist = GetEndLadderSegment();
3124 Double_t beamaxistransvector = fgkCarbonFiberJunctionWidth;
3125 Int_t ssdlaysensorsnumber = (iLayer==5 ?
3126 fgkSSDLay5SensorsNumber :
3127 fgkSSDLay6SensorsNumber);
3128 for(Int_t i=0; i<ssdlaysensorsnumber; i++) ladder->AddNode(i%2==0 ?
3129 laddersegment[iLayer==5 ? 0 : 1] :
3130 laddersegment[iLayer==5 ? 1 : 0],
3131 ssdlaysensorsnumber-i-1,new TGeoTranslation(-0.5*fgkCarbonFiberTriangleLength,
3132 beamaxistransvector*i,0.));
3133 ladder->AddNode((TGeoVolume*)endladdersegmentlist->At(0),1,
3134 new TGeoTranslation("",-0.5*fgkCarbonFiberTriangleLength,
3135 fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber,0.));
3136 ladder->AddNode((TGeoVolume*)endladdersegmentlist->At(1),1,
3137 new TGeoCombiTrans("",0.5*fgkCarbonFiberTriangleLength,
3138 0.,0.,new TGeoRotation("",180.,0.,0.)));
3139/////////////////////////////////////////////////////////////////////////////
3140/// Placing Ladder Cables
3141/////////////////////////////////////////////////////////////////////////////
3142 SetLadderCableCombiTransMatrix(iLayer);
3143 Int_t sidecablenumber[2] = {0,0};
3144 switch(iLayer){
3145 case 5:
3146 sidecablenumber[0] = fgkSSDLay5SensorsNumber/2+1;
3147 sidecablenumber[1] = sidecablenumber[0]-2;
3148 break;
3149 case 6:
3150 sidecablenumber[0] = (fgkSSDLay6SensorsNumber-1)/2+1;
3151 sidecablenumber[1] = sidecablenumber[0]-1;
3152 break;
3153 }
3154 const Double_t* carbonfibertomoduleposition =
3155 fLadderSegmentCombiTransMatrix[1]->GetTranslation();
3156 Double_t ssdendladdercablelength[4];
3157 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
3158 + fgkSSDSensorLength
3159 - fgkSSDModuleStiffenerPosition[1]
3160 - fgkSSDStiffenerWidth
3161 - fgkSSDFlexWidth[0]
3162 + fgkEndLadderCarbonFiberLowerJunctionLength[1];
3163 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
3164 + fgkSSDModuleStiffenerPosition[1]
3165 + fgkSSDStiffenerWidth
3166 + fgkEndLadderCarbonFiberLowerJunctionLength[1];
3167 ssdendladdercablelength[2] = ssdendladdercablelength[1]
3168 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3169 + fgkEndLadderCarbonFiberLowerJunctionLength[0];
3170 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
3171 + carbonfibertomoduleposition[1]
3172 - fgkSSDModuleStiffenerPosition[1]
3173 - fgkSSDStiffenerWidth)
3174 + fgkEndLadderCarbonFiberLowerJunctionLength[1];
3175 TList* laddercableassemblylist[4];
3176 const Int_t kendladdercablesnumber = 4;
3177 for(Int_t i=0; i<kendladdercablesnumber; i++){
3178 laddercableassemblylist[i] =
3179 GetLadderCableAssemblyList(sidecablenumber[i<2?0:1],
3180 ssdendladdercablelength[i]);
3181 ladder->AddNode((TGeoVolume*)laddercableassemblylist[i]->At(i%2==0?0:1),
3182 i<2?1:2,fLadderCableCombiTransMatrix[i]);
3183 }
3184 return ladder;
3185}
3186////////////////////////////////////////////////////////////////////////////////
3187TGeoVolume* AliITSv11GeometrySSD::GetLayer(Int_t iLayer){
3188 /////////////////////////////////////////////////////////////
3189 // Method generating the Layer5 or Layer6
3190 /////////////////////////////////////////////////////////////
3191 TGeoVolume* layer = new TGeoVolumeAssembly(iLayer==5 ? "ITSssdLayer5"
3192 : "ITSssdLayer6");
3193 TGeoVolume* ladder = GetLadder(iLayer);
3194 /////////////////////////////////////////////////////
3195 // Setting the CombiTransformation to pass ITS center
3196 /////////////////////////////////////////////////////
3197 Double_t itscentertransz = iLayer==5 ? fgkSSDLay5LadderLength
3198 - fgkLay5CenterITSPosition:
3199 fgkSSDLay6LadderLength
3200 - fgkLay6CenterITSPosition;
3201 Double_t itssensorytrans = fgkSSDModuleCoolingBlockToSensor
3202 + 0.5* fgkCoolingTubeSupportHeight
3203 -(iLayer==5 ? fgkSSDSensorSideSupportHeight[1]
3204 - fgkSSDSensorSideSupportHeight[0]: 0.);
3205 TGeoRotation* itscenterrot[3];
3206 itscenterrot[0] = new TGeoRotation("ITSCenterRot0",90.,180.,-90.);
3207 itscenterrot[1] = new TGeoRotation("ITSCenterRot1",0.,90.,0.);
3208 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
3209 TGeoCombiTrans* itscentercombitrans = new TGeoCombiTrans("ITSCenterCombiTrans",0.,
3210 fgkSSDMountingBlockHeight[1]+itssensorytrans,
3211 fgkEndLadderCarbonFiberLowerJunctionLength[1]
3212 - itscentertransz,itscenterrot[2]);
3213 /////////////////////////////////////////////////////
3214 // Setting the Ladder into the Layer
3215 /////////////////////////////////////////////////////
3216 TGeoCombiTrans* lay5laddercombitrans[fgkSSDLay5LadderNumber];
3217 TGeoCombiTrans* lay6laddercombitrans[fgkSSDLay6LadderNumber];
3218 TGeoHMatrix* lay5ladderhmatrix[fgkSSDLay5LadderNumber];
3219 TGeoHMatrix* lay6ladderhmatrix[fgkSSDLay6LadderNumber];
3220 if(iLayer==5){
3221 Double_t lay5ladderangleposition = 360./fgkSSDLay5LadderNumber;
3222 char lay5laddercombitransname[30], lay5ladderrotname[30];
3223 for(Int_t i=0; i<fgkSSDLay5LadderNumber;i++){
3224 sprintf(lay5laddercombitransname,"Lay5LadderCombiTrans%i",i);
3225 sprintf(lay5ladderrotname,"Lay5LaddeRot%i",i);
3226 Double_t lay5layerradius = (i%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
3227 lay5laddercombitrans[i] = new TGeoCombiTrans(lay5laddercombitransname,
3228 lay5layerradius * TMath::Cos((i+1)
3229 * lay5ladderangleposition*TMath::DegToRad()),
3230 lay5layerradius * TMath::Sin((i+1)
3231 * lay5ladderangleposition*TMath::DegToRad()),0.,
3232 new TGeoRotation(lay5ladderrotname,(i+1)
3233 * lay5ladderangleposition-90,0.,0.));
3234 lay5ladderhmatrix[i] = new TGeoHMatrix((*lay5laddercombitrans[i])
3235 * (*itscentercombitrans));
3236 layer->AddNode(ladder,i,lay5ladderhmatrix[i]);
3237 }
3238 }
3239 else{
3240 Double_t lay6ladderangleposition = 360./fgkSSDLay6LadderNumber;
3241 char lay6laddercombitransname[30], lay6ladderrotname[30];
3242 for(Int_t i=0; i<fgkSSDLay6LadderNumber;i++){
3243 sprintf(lay6laddercombitransname,"Lay6LadderCombiTrans%i",i);
3244 sprintf(lay6ladderrotname,"Lay6LaddeRot%i",i);
3245 Double_t lay6layerradius = (i%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
3246 lay6laddercombitrans[i] = new TGeoCombiTrans(lay6laddercombitransname,
3247 lay6layerradius * TMath::Cos((i+1)
3248 * lay6ladderangleposition*TMath::DegToRad()),
3249 lay6layerradius * TMath::Sin((i+1)
3250 * lay6ladderangleposition*TMath::DegToRad()),0.,
3251 new TGeoRotation(lay6ladderrotname,(i+1)
3252 * lay6ladderangleposition-90,0.,0.));
3253 lay6ladderhmatrix[i] = new TGeoHMatrix((*lay6laddercombitrans[i])
3254 * (*itscentercombitrans));
3255 layer->AddNode(ladder,i,lay6ladderhmatrix[i]);
3256 }
3257 }
3258 return layer;
3259}
3260////////////////////////////////////////////////////////////////////////////////
3261void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
3262 /////////////////////////////////////////////////////////////
3263 // Insert the layer 5 in the mother volume.
3264 /////////////////////////////////////////////////////////////
3265 if (! moth) {
3266 printf("Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!\n");
3267 return;
3268 };
3269 fMotherVol = moth;
3270 moth->AddNode(GetLayer(5),1,0);
3271 }
3272////////////////////////////////////////////////////////////////////////////////
3273void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
3274 /////////////////////////////////////////////////////////////
3275 // Insert the layer 6 in the mother volume.
3276 /////////////////////////////////////////////////////////////
3277 if (! moth) {
3278 printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
3279 return;
3280 };
3281 fMotherVol = moth;
3282 moth->AddNode(GetLayer(6),1,0);
3283 }
3284////////////////////////////////////////////////////////////////////////////////
3285TGeoArb8* AliITSv11GeometrySSD::GetTrapezoidShape(TVector3* vertexpos[],
3286 Double_t* width, Double_t height, char* shapename) const{
3287 /////////////////////////////////////////////////////////////
3288 // Method generating a trapezoid shape
3289 /////////////////////////////////////////////////////////////
3290 const Int_t kvertexnumber = 4;
3291 const Int_t ktransvectnumber = 2;
3292 TVector3* vertex[kvertexnumber];
3293 TVector3* transvector[2];
3294 for(Int_t i=0; i<ktransvectnumber; i++)
3295 transvector[i] = new TVector3(0.,width[i]);
3296 /////////////////////////////////////////////////////////////
3297 //Setting the vertices
3298 /////////////////////////////////////////////////////////////
3299 vertex[0] = new TVector3(*vertexpos[0]);
3300 vertex[1] = new TVector3(*vertexpos[1]);
3301 vertex[2] = new TVector3(*vertex[1]+*transvector[1]);
3302 vertex[3] = new TVector3(*vertex[0]+*transvector[0]);
3303 TGeoArb8* trapezoidshape = new TGeoArb8(shapename,0.5*height);
3304 for(Int_t i=0; i<2*kvertexnumber; i++)
3305 trapezoidshape->SetVertex(i,vertex[(i<kvertexnumber ? i : i-kvertexnumber)]->X(),
3306 vertex[(i<kvertexnumber ? i : i-kvertexnumber)]->Y());
3307 return trapezoidshape;
3308}
3309////////////////////////////////////////////////////////////////////////////////
3310TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
3311 Double_t height, char* shapename, Int_t isign) const{
3312 /////////////////////////////////////////////////////////////
3313 // Method generating an Arb shape
3314 /////////////////////////////////////////////////////////////
3315 const Int_t kvertexnumber = 8;
3316 const Int_t ktransvectnumber = 2;
3317 TVector3* vertex[kvertexnumber];
3318 TVector3* transvector[2];
3319 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
3320 /////////////////////////////////////////////////////////////
3321 //Setting the vertices for TGeoArb8
3322 /////////////////////////////////////////////////////////////
3323 vertex[0] = new TVector3(*vertexpos[0]);
3324 vertex[1] = new TVector3(*vertexpos[1]);
3325 vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
3326 vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
3327 vertex[4] = new TVector3(*vertexpos[2]);
3328 vertex[5] = new TVector3(*vertexpos[3]);
3329 vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
3330 vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
3331 /////////////////////////////////////////////////////////////
3332 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
3333 for(Int_t i = 0; i<kvertexnumber;i++)
3334 arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
3335 return arbshape;
3336}
3337////////////////////////////////////////////////////////////////////////////////
3338TGeoArb8* AliITSv11GeometrySSD::GetTriangleShape(TVector3* vertexpos[],
3339 Double_t height, char* shapename) const{
3340 /////////////////////////////////////////////////////////////
3341 // Method generating a triangle shape
3342 /////////////////////////////////////////////////////////////
3343 const Int_t kvertexnumber = 4;
3344 TVector3* vertex[kvertexnumber];
3345//////////////////////////////////////
3346 //Setting the vertices for TGeoArb8
3347 ////////////////////////////////////
3348 for(Int_t i = 0; i<kvertexnumber; i++)
3349 vertex[i] = new TVector3(i!=kvertexnumber-1?*vertexpos[i]:*vertex[kvertexnumber-1-i]);
3350 TGeoArb8* triangleshape = new TGeoArb8(shapename,0.5*height);
3351 for(Int_t i = 0; i<2*kvertexnumber; i++)
3352 triangleshape->SetVertex(i,vertex[(i < kvertexnumber ? i: i-kvertexnumber)]->X(),
3353 vertex[(i < kvertexnumber ? i : i-kvertexnumber)]->Y());
3354 return triangleshape;
3355}
3356////////////////////////////////////////////////////////////////////////////////
3357TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
3358 /////////////////////////////////////////////////////////////
3359 // Given an axis specified by param, it gives the reflection of the point
3360 // respect to the axis
3361 /////////////////////////////////////////////////////////////
3362 TVector3* n = new TVector3(param[0],param[1],param[2]);
3363 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
3364 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
3365 return reflectedvector;
3366}
3367////////////////////////////////////////////////////////////////////////////////
3368TGeoCombiTrans* AliITSv11GeometrySSD::AddTranslationToCombiTrans(TGeoCombiTrans* ct,
3369 Double_t dx,
3370 Double_t dy,
3371 Double_t dz) const{
3372 /////////////////////////////////////////////////////////////
3373 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
3374 /////////////////////////////////////////////////////////////
3375 TGeoCombiTrans* combiTrans = new TGeoCombiTrans(*ct);
3376 const Double_t *vect = combiTrans->GetTranslation();
3377 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
3378 combiTrans->SetTranslation(newvect);
3379 return combiTrans;
3380}
3381////////////////////////////////////////////////////////////////////////////////
3382TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
3383 /////////////////////////////////////////////////////////////
3384 // Method returning the Medium type
3385 /////////////////////////////////////////////////////////////
3386 char ch[30];
3387 sprintf(ch, "ITS_%s",mediumName);
3388 TGeoMedium* medium = gGeoManager->GetMedium(ch);
3389 if (! medium)
3390 printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
3391 return medium;
3392}
3393////////////////////////////////////////////////////////////////////////////////
3394//To be interfaced with AliRoot Materials file
3395////////////////////////////////////////////////////////////////////////////////
3396/*void AliITSv11GeometrySSD::CreateMaterials(){
3397///////////////////////////////////
3398// This part has to be modified
3399///////////////////////////////////
3400// Float_t ifield = 2.000;
3401// Float_t fieldm = 10.000;
3402// Int_t ifield = gAlice->Field()->Integ();
3403// Float_t fieldm = gAlice->Field()->Max();
3404 ///////////////////////////////////
3405 // Silicon for Sensor
3406 ///////////////////////////////////
3407 Int_t SINumber = 0;
3408 TGeoMaterial* SiMaterial = new TGeoMaterial("SiMaterial");
3409 TGeoMedium* Silicon = new TGeoMedium("Silicon",SINumber,SiMaterial);
3410 fSSDSensorMedium = Silicon;
3411 ///////////////////////////////////
3412 // Silicon Mixture for Sensor
3413 ///////////////////////////////////
3414 Int_t SiMixtureNumber = 1;
3415 TGeoMaterial* SiMixtureMaterial = new TGeoMaterial("SiMixtureMaterial");
3416 TGeoMedium* SiliconMixture = new TGeoMedium("SiliconMixture",SiMixtureNumber,SiMixtureMaterial);
3417 fSSDChipMedium = SiliconMixture;
3418 ///////////////////////////////////
3419 // Stiffener Components Materials
3420 ///////////////////////////////////
3421 Int_t K1100Number = 2;
3422 TGeoMaterial* K1100Material = new TGeoMaterial("K1100Material");
3423 TGeoMedium* K1100 = new TGeoMedium("K1100",K1100Number,K1100Material);
3424 fSSDStiffenerMedium = K1100;
3425 ///////////////////////////
3426 // Stiffener Connectors
3427 ///////////////////////////
3428 Int_t SnMaterialNumber = 3;
3429 TGeoMaterial* SnMaterial = new TGeoMaterial("SnMaterial");
3430 TGeoMedium* SnMedium = new TGeoMedium("SnMedium",SnMaterialNumber,
3431 SnMaterial);
3432 fSSDStiffenerConnectorMedium = SnMedium;
3433 ////////////////////////////////
3434 // Stiffener 0603-1812 Capacitor
3435 ////////////////////////////////
3436 Int_t Al2O3Number = 4;
3437 TGeoMaterial* Al2O3Material = new TGeoMaterial("Al2O3Material");
3438 TGeoMedium* Al2O3Medium = new TGeoMedium("Al2O3Medium",
3439 Al2O3Number,
3440 Al2O3Material);
3441 fSSDStiffener0603CapacitorMedium = Al2O3Medium;
3442 fSSDStiffener1812CapacitorMedium = Al2O3Medium;
3443 ///////////////////////////
3444 // Stiffener Hybrid Wire
3445 ///////////////////////////
3446 Int_t CuHybridWireNumber = 5;
3447 TGeoMaterial* CuHybridWireMaterial = new TGeoMaterial("CuHybridWireMaterial");
3448 TGeoMedium* CuHybridWireMedium = new TGeoMedium("CuHybridWireMedium",
3449 CuHybridWireNumber,
3450 CuHybridWireMaterial);
3451 fSSDStiffenerHybridWireMedium = CuHybridWireMedium;
3452 ///////////////////////////
3453 // Al for Cooling Block
3454 ///////////////////////////
3455 Int_t AlCoolBlockNumber = 6;
3456 TGeoMaterial* AlCoolBlockMaterial = new TGeoMaterial("AlCoolBlockMaterial");
3457 TGeoMedium* AlCoolBlockMedium = new TGeoMedium("AlCoolBlockMedium",
3458 AlCoolBlockNumber,
3459 AlCoolBlockMaterial);
3460 fSSDAlCoolBlockMedium = AlCoolBlockMedium;
3461 //////////////////////////////////////////////////////
3462 // Kapton and Al for Chip Cable Flex and Ladder Cables
3463 //////////////////////////////////////////////////////
3464 Int_t KaptonBlockNumber = 7;
3465 TGeoMaterial* KaptonMaterial = new TGeoMaterial("KaptonMaterial");
3466 TGeoMedium* KaptonMedium = new TGeoMedium("KaptonMedium",
3467 KaptonBlockNumber,
3468 KaptonMaterial);
3469 Int_t AlTraceBlockNumber = 8;
3470 TGeoMaterial* AlTraceMaterial = new TGeoMaterial("AlTraceMaterial");
3471 TGeoMedium* AlTraceMedium = new TGeoMedium("AlTraceMedium",
3472 AlTraceBlockNumber,
3473 AlTraceMaterial);
3474 fSSDKaptonChipCableMedium = KaptonMedium;
3475 fSSDAlTraceChipCableMedium = AlTraceMedium;
3476 fSSDKaptonFlexMedium = KaptonMedium;
3477 fSSDAlTraceFlexMedium = AlTraceMedium;
3478 fSSDKaptonLadderCableMedium = KaptonMedium;
3479 fSSDAlTraceLadderCableMedium = AlTraceMedium;
3480 /////////////////////////////////////////////////////////////////
3481 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
3482 //////////////////////////////////////////////////////////////////
3483 Int_t M55JNumber = 9;
3484 TGeoMaterial* M55JMaterial = new TGeoMaterial("M55JMaterial");
3485 TGeoMedium* M55JMedium = new TGeoMedium("M55JMedium",M55JNumber,
3486 M55JMaterial);
3487 fSSDCarbonFiberMedium = M55JMedium;
3488 fSSDMountingBlockMedium = M55JMedium;
3489 /////////////////////////////////////////////////////////////////
3490 // G10 for Detector Leg, TubeHolder
3491 //////////////////////////////////////////////////////////////////
3492 Int_t G10Number = 10;
3493 TGeoMaterial* G10Material = new TGeoMaterial("G10Material");
3494 TGeoMedium* G10Medium = new TGeoMedium("G10Medium",G10Number,
3495 G10Material);
3496 fSSDTubeHolderMedium = G10Medium;
3497 fSSDSensorSupportMedium = G10Medium;
3498 /////////////////////////////////////////////////////////////////
3499 // Water and Phynox for Cooling Tube
3500 //////////////////////////////////////////////////////////////////
3501 Int_t WaterNumber = 11;
3502 TGeoMaterial* WaterMaterial = new TGeoMaterial("WaterMaterial");
3503 TGeoMedium* WaterMedium = new TGeoMedium("WaterMedium",WaterNumber,
3504 WaterMaterial);
3505 fSSDCoolingTubeWater = WaterMedium;
3506 Int_t PhynoxNumber = 12;
3507 TGeoMaterial* PhynoxMaterial = new TGeoMaterial("PhynoxMaterial");
3508 TGeoMedium* PhynoxMedium = new TGeoMedium("PhynoxMedium",PhynoxNumber,
3509 PhynoxMaterial);
3510 fSSDCoolingTubePhynox = PhynoxMedium;
3511}
3512*/
3513void AliITSv11GeometrySSD::CreateMaterials(){
3514///////////////////////////////////
3515// This part has to be modified
3516///////////////////////////////////
3517 ///////////////////////////////////
3518 // Silicon for Sensor
3519 ///////////////////////////////////
3520 fSSDSensorMedium = GetMedium("Si");
3521 ///////////////////////////////////
3522 // Silicon Mixture for Sensor
3523 ///////////////////////////////////
3524 fSSDChipMedium = GetMedium("SPD SI CHIP$");
3525 fSSDChipGlueMedium = GetMedium("EPOXY$");
3526 ///////////////////////////////////
3527 // Stiffener Components Materials
3528 ///////////////////////////////////
3529 fSSDStiffenerMedium = GetMedium("ITSsddCarbonM55J");
3530 ///////////////////////////
3531 // Stiffener Connectors
3532 ///////////////////////////
3533 fSSDStiffenerConnectorMedium = GetMedium("COPPER");
3534 ////////////////////////////////
3535 // Stiffener 0603-1812 Capacitor
3536 ////////////////////////////////
3537 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3");
3538 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3");
3539 ///////////////////////////
3540 // Stiffener Hybrid Wire
3541 ///////////////////////////
3542 fSSDStiffenerHybridWireMedium = GetMedium("COPPER");
3543 ///////////////////////////
3544 // Al for Cooling Block
3545 ///////////////////////////
3546 fSSDAlCoolBlockMedium = GetMedium("ITSal");
3547 //////////////////////////////////////////////////////
3548 // Kapton and Al for Chip Cable Flex and Ladder Cables
3549 //////////////////////////////////////////////////////
3550 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)");
3551 fSSDAlTraceChipCableMedium = GetMedium("ITSal");
3552 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)");
3553 fSSDAlTraceFlexMedium = GetMedium("ITSal");
3554 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)");
3555 fSSDAlTraceLadderCableMedium = GetMedium("ITSal");
3556 /////////////////////////////////////////////////////////////////
3557 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
3558 //////////////////////////////////////////////////////////////////
3559 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
3560 /////////////////////////////////////////////////////////////////
3561 // G10 for Detector Leg, TubeHolder
3562 //////////////////////////////////////////////////////////////////
3563 fSSDTubeHolderMedium = GetMedium("G10FR4$");
3564 fSSDSensorSupportMedium = GetMedium("G10FR4$");
3565 fSSDMountingBlockMedium = GetMedium("G10FR4$");
3566 fSSDMountingBlockMedium = GetMedium("G10FR4$");
3567 /////////////////////////////////////////////////////////////////
3568 // Water and Phynox for Cooling Tube
3569 //////////////////////////////////////////////////////////////////
3570 fSSDCoolingTubeWater = GetMedium("WATER");
3571 fSSDCoolingTubePhynox = GetMedium("INOX$");
3572}
3573/////////////////////////////////////////////////////////////////////
3574