]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITSv11GeometrySSD.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Methods for Init and Read have been splitted for the 3 subdetectors. Recpoints proces...
[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySSD.cxx
CommitLineData
d7599219 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
9b0c60ab 16/* $Id$ */
d7599219 17
18//*************************************************************************
19// SSD geometry, based on ROOT geometrical modeler
20//
21// Enrico Cattaruzza ecattar@ts.infn.it
22//*************************************************************************
23#include "TMath.h"
24#include "TGeoVolume.h"
d7599219 25#include "TGeoMatrix.h"
26#include <TGeoManager.h>
d7599219 27#include "TVector3.h"
28#include "TGeoArb8.h"
29#include "TList.h"
30#include "TGeoMatrix.h"
31#include "TGeoCompositeShape.h"
32#include "TGeoTube.h"
33#include "TGeoBBox.h"
bf210566 34#include "TGeoXtru.h"
9b0c60ab 35#include "TGeoTorus.h"
36#include "TGeoPgon.h"
37#include "TRotation.h"
44285dfa 38#include "AliITSv11GeometrySSD.h"
d7599219 39/////////////////////////////////////////////////////////////////////////////////
bf210566 40// Names of the Sensitive Volumes of Layer 5 and Layer 6
41/////////////////////////////////////////////////////////////////////////////////
42const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName5 = "ITSsddSensitivL5";
43const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName6 = "ITSsddSensitivL6";
44/////////////////////////////////////////////////////////////////////////////////
d7599219 45//Parameters for SSD Geometry
46/////////////////////////////////////////////////////////////////////////////////
47// Layer5 (lengths are in mm and angles in degrees)
48/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 49const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
d7599219 50const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
51const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
9acf2ecc 52const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
53const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
54const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
d7599219 55/////////////////////////////////////////////////////////////////////////////////
56// Layer6 (lengths are in mm and angles in degrees)
57/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 58const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
d7599219 59const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
60const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
9acf2ecc 61const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
62const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
63const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
d7599219 64/////////////////////////////////////////////////////////////////////////////////
65// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
66/////////////////////////////////////////////////////////////////////////////////
67const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
9acf2ecc 68const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
69const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
70const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
71const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
bf210566 72const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
73const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
9acf2ecc 74const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
d7599219 75/////////////////////////////////////////////////////////////////////////////////
76// Stiffener (lengths are in mm and angles in degrees)
77/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 78const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
79const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
bf210566 80//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 3.315;
9acf2ecc 81const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm;
82const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
bf210566 83const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
9acf2ecc 84const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
85const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
86const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
87const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
bf210566 88const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 0.700*fgkmm; // multiplied by 0.5
9acf2ecc 89const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
90const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
bf210566 91const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] =
92 {44.32*fgkmm, 0.33*fgkmm};
93const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
94const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
95const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
d7599219 96const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight =
bf210566 97 0.25*fgkSSDStiffenerHeight;
98const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
99const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
d7599219 100/////////////////////////////////////////////////////////////////////////////////
101// Cooling Block (lengths are in mm and angles in degrees)
102/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 103const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
104const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
bf210566 105const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
106 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
d7599219 107const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
bf210566 108 {1.000*fgkmm, 0.120*fgkmm};
d7599219 109const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
bf210566 110 {1.900*fgkmm, 0.400*fgkmm};
d7599219 111const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
9acf2ecc 112 1.500*fgkmm;
d7599219 113const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
9acf2ecc 114 0.300*fgkmm;
d7599219 115/////////////////////////////////////////////////////////////////////////////////
116// SSD Sensor (lengths are in mm and angles in degrees)
117/////////////////////////////////////////////////////////////////////////////////
118const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
bf210566 119 "SSDSensorSensitiveVol";
9acf2ecc 120const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
121const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
122const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
d7599219 123const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
9acf2ecc 124 fgkSSDSensorLength-39.1*fgkmm;
bf210566 125const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
126const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
d7599219 127/////////////////////////////////////////////////////////////////////////////////
128// Flex (lengths are in mm and angles in degrees)
129/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 130const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
d7599219 131const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
bf210566 132 {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
133 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
134 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
135 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
136 - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
d7599219 137const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
bf210566 138 { 9.340*fgkmm, 5.380*fgkmm};
d7599219 139const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
bf210566 140 { 0.030*fgkmm, 0.020*fgkmm};
d7599219 141const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
9acf2ecc 142const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
143const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
d7599219 144const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
bf210566 145 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
d7599219 146const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
bf210566 147 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
d7599219 148/////////////////////////////////////////////////////////////////////////////////
149// SSD Ladder Cable (lengths are in mm and angles in degrees)
150/////////////////////////////////////////////////////////////////////////////////
bf210566 151const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
d7599219 152/////////////////////////////////////////////////////////////////////////////////
153// SSD Module (lengths are in mm and angles in degrees)
154/////////////////////////////////////////////////////////////////////////////////
155const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
bf210566 156 { 1.000*fgkmm, 3.900*fgkmm};
d7599219 157const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
9acf2ecc 158 45.600*fgkmm;
d7599219 159const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
9acf2ecc 160 5.075*fgkmm;
d7599219 161/////////////////////////////////////////////////////////////////////////////////
162// Sensor Support (lengths are in mm and angles in degrees)
163/////////////////////////////////////////////////////////////////////////////////
bf210566 164const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
165 5.800*fgkmm;
d7599219 166const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
bf210566 167 2.000*fgkmm;
d7599219 168const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
bf210566 169 { 4.620*fgkmm, 5.180*fgkmm};
170const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
171 { 0.450*fgkmm, 0.450*fgkmm};
172const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
173 = 0.5 * (fgkSSDModuleSensorSupportDistance
174 + fgkSSDSensorSideSupportThickness[0])
175 - fgkSSDSensorSideSupportLength;
d7599219 176const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
bf210566 177 5.250*fgkmm;
d7599219 178const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
bf210566 179 1.680*fgkmm;
180const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
181 = {fgkSSDSensorSideSupportHeight[0]
182 + fgkSSDSensorSideSupportThickness[0],
183 fgkSSDSensorSideSupportHeight[1]
184 + fgkSSDSensorSideSupportThickness[1]};
185const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
186 = {fgkSSDSensorSideSupportThickness[0],
187 fgkSSDSensorSideSupportThickness[1]};
d7599219 188const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
bf210566 189 19.000*fgkmm;
d7599219 190/////////////////////////////////////////////////////////////////////////////////
191// Chip Cables (lengths are in mm and angles in degrees)
192/////////////////////////////////////////////////////////////////////////////////
193const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
bf210566 194 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
d7599219 195const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
bf210566 196 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
197 - (fgkSSDSensorSideSupportHeight[1]
198 - fgkSSDSensorSideSupportHeight[0])
199 - fgkSSDCoolingBlockHoleCenter
200 - fgkSSDStiffenerHeight
201 - fgkSSDChipHeight-fgkSSDSensorHeight,
202 fgkSSDModuleCoolingBlockToSensor
203 - fgkSSDCoolingBlockHoleCenter
204 - fgkSSDStiffenerHeight
205 - fgkSSDChipHeight-fgkSSDSensorHeight};
d7599219 206const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
bf210566 207 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
d7599219 208/////////////////////////////////////////////////////////////////////////////////
209// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
210/////////////////////////////////////////////////////////////////////////////////
211const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
bf210566 212 3.820*fgkmm;
213//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
214// 3.780;
d7599219 215const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
bf210566 216 fgkSSDSensorLength-fgkSSDSensorOverlap;
d7599219 217const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
bf210566 218 { 0.86*fgkmm, 0.30*fgkmm};
d7599219 219const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
bf210566 220 { 30.00, 90.00};
d7599219 221const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
bf210566 222 1.78*fgkmm;
d7599219 223/////////////////////////////////////////////////////////////////////////////////
224//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
225/////////////////////////////////////////////////////////////////////////////////
bf210566 226const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
227 = fgkSSDModuleSensorSupportDistance
228 - 2. * fgkCarbonFiberJunctionToSensorSupport;
229const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
d7599219 230const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
bf210566 231 { 0.751*fgkmm, 0.482*fgkmm};
232const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
233 1.630*fgkmm;
234const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
235const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
236 = fgkCarbonFiberTriangleLength
237 - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
238 / TMath::Cos(fgkCarbonFiberTriangleAngle
239 * TMath::DegToRad());
240const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
241 = 0.5*(fgkCarbonFiberJunctionWidth
242 - fgkCarbonFiberSupportWidth)
243 - fgkCarbonFiberSupportTopEdgeDist[0]
244 - fgkCarbonFiberSupportWidth;
d7599219 245/////////////////////////////////////////////////////////////////////////////////
246// Carbon Fiber Lower Support Parameters (lengths are in mm)
247/////////////////////////////////////////////////////////////////////////////////
248const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
9acf2ecc 249 = 0.950*fgkmm;
d7599219 250const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
9acf2ecc 251 = 1.600*fgkmm;
d7599219 252const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
9acf2ecc 253 = 0.830*fgkmm;
d7599219 254const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
255 = 0.5*fgkCarbonFiberSupportWidth;
256const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
bf210566 257 = fgkCarbonFiberJunctionWidth
258 - 2. * (fgkCarbonFiberLowerSupportWidth
259 + fgkCarbonFiberLowerSupportVolumeSeparation);
d7599219 260const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
bf210566 261 = {fgkCarbonFiberLowerSupportWidth
262 + fgkCarbonFiberLowerSupportVolumeSeparation,
263 fgkCarbonFiberLowerSupportWidth
264 + fgkCarbonFiberLowerSupportVolumeSeparation
265 + fgkCarbonFiberLowerSupportTransverseWidth};
d7599219 266/////////////////////////////////////////////////////////////////////////////////
267// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
268/////////////////////////////////////////////////////////////////////////////////
269const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
bf210566 270 {0.5 * (fgkSSDLay5LadderLength
271 - fgkSSDLay5SensorsNumber
272 * fgkCarbonFiberJunctionWidth
273 - fgkCarbonFiberLowerSupportWidth),
274 0.5 * (fgkSSDLay5LadderLength
275 - fgkSSDLay5SensorsNumber
276 * fgkCarbonFiberJunctionWidth
277 + fgkCarbonFiberLowerSupportWidth)};
d7599219 278const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
bf210566 279 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
280 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
d7599219 281const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
bf210566 282 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
283 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
9b0c60ab 284const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
285 {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
d7599219 286/////////////////////////////////////////////////////////////////////////////////
287// Cooling Tube Support (lengths are in mm and angles in degrees)
288/////////////////////////////////////////////////////////////////////////////////
bf210566 289const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
d7599219 290const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
291 = fgkSSDCoolingBlockHoleRadius[0];
bf210566 292const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
293const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
294const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
d7599219 295const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
bf210566 296 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
297const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
298 11.70*fgkmm;
d7599219 299/////////////////////////////////////////////////////////////////////////////////
300// Cooling Tube (lengths are in mm and angles in degrees)
301/////////////////////////////////////////////////////////////////////////////////
bf210566 302const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
303const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm;
304const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
d7599219 305 fgkCarbonFiberJunctionWidth;
306const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
bf210566 307 fgkSSDModuleSensorSupportDistance
308 + fgkSSDCoolingBlockLength;
9b0c60ab 309const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
d7599219 310/////////////////////////////////////////////////////////////////////////////////
311// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
312/////////////////////////////////////////////////////////////////////////////////
313const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
bf210566 314 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
d7599219 315const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
bf210566 316 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
d7599219 317const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
bf210566 318 20.0*fgkmm;
d7599219 319const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
bf210566 320 40.0;
d7599219 321const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
322 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
323const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
bf210566 324 2.5*fgkmm;
d7599219 325const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
bf210566 326 { 56.0*fgkmm, 12.0*fgkmm};
d7599219 327const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
bf210566 328 { 5.0*fgkmm, 2.9*fgkmm};
d7599219 329const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
bf210566 330 1.0*fgkmm;
d7599219 331const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
bf210566 332 6.0*fgkmm;
d7599219 333const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth =
bf210566 334 4.0*fgkmm;
d7599219 335const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
bf210566 336 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
d7599219 337/////////////////////////////////////////////////////////////////////////////////
9b0c60ab 338// SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
339/////////////////////////////////////////////////////////////////////////////////
340const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
341const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
342const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
343const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
344const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
345/////////////////////////////////////////////////////////////////////////////////
346// SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
347/////////////////////////////////////////////////////////////////////////////////
348const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
349const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
350const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
351 - fgkSSDMountingBlockHeight[1]
352 + 0.5*fgkCoolingTubeSupportHeight
353 + fgkSSDModuleCoolingBlockToSensor
354 - fgkMountingBlockSupportDownHeight,
355 fgkSSDLay6RadiusMin
356 - fgkSSDMountingBlockHeight[1]
357 + 0.5*fgkCoolingTubeSupportHeight
358 + fgkSSDModuleCoolingBlockToSensor
359 - fgkMountingBlockSupportDownHeight};
360const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
361 - fgkSSDMountingBlockHeight[1]
362 + 0.5*fgkCoolingTubeSupportHeight
363 + fgkSSDModuleCoolingBlockToSensor
364 - fgkMountingBlockSupportRadius[0],
365 fgkSSDLay6RadiusMax
366 - fgkSSDMountingBlockHeight[1]
367 + 0.5*fgkCoolingTubeSupportHeight
368 + fgkSSDModuleCoolingBlockToSensor
369 - fgkMountingBlockSupportRadius[1]};
370const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
371const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
372const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
373/////////////////////////////////////////////////////////////////////////////////
374// SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
375/////////////////////////////////////////////////////////////////////////////////
376const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
377const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
378const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
379const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
380 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
381const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
382 {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
383const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
384 {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
385const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
386const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
387const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
388const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
389const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
390const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
391/////////////////////////////////////////////////////////////////////////////////
392// SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
393/////////////////////////////////////////////////////////////////////////////////
394const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
395const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
396const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
397/////////////////////////////////////////////////////////////////////////////////
398// SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
399/////////////////////////////////////////////////////////////////////////////////
400const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
401 {10.5*fgkmm,9.25*fgkmm};
402const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
403const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
404const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
405 {182.3,177.9,84.4,70.0,35.0};
406const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
407 {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
408const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
409/////////////////////////////////////////////////////////////////////////////////
410// SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
411/////////////////////////////////////////////////////////////////////////////////
412const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
413 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
414const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
415 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
416 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
417const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
418/////////////////////////////////////////////////////////////////////////////////
419// SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
420/////////////////////////////////////////////////////////////////////////////////
421const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
422 {62.0*fgkmm,21.87*fgkmm};
423const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
424 {47.1*fgkmm,0.35*fgkmm};
425const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
426 1.0*fgkmm;
427const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
428const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
429 {43.5*fgkmm, 0.70*fgkmm};
430const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
431 0.15*fgkmm;
432const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
433 19.0*fgkmm;
434const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
435 {4.80*fgkmm,1.1*fgkmm};
436const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
437 {3.3*fgkmm,1.10*fgkmm};
438const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
439 2.1*fgkmm;
440const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
441 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
442const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
443 {1.9*fgkmm,0.15*fgkmm};
444const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
445 19*fgkmm;
446const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
447 1.0*fgkmm;
448const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
449 3.6*fgkmm;
450const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
451 61.0*fgkmm;
452const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
453 5.97*fgkmm;
454const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
455const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
456 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
457 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
458const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
459 {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
460const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
461 1.0*fgkmm;
462const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
463 = 0.15*fgkmm;
464const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
465 20.0*fgkmm;
466const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
467const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
468const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
469const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
470const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
471/////////////////////////////////////////////////////////////////////////////////
472// SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
473/////////////////////////////////////////////////////////////////////////////////
474const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
475const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
476const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {365.0*fgkmm,430.0*fgkmm};
477const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
478const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
479const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
480const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
481const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
482const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
483/////////////////////////////////////////////////////////////////////////////////
44285dfa 484ClassImp(AliITSv11GeometrySSD)
485/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 486AliITSv11GeometrySSD::AliITSv11GeometrySSD():
487 AliITSv11Geometry(),
44285dfa 488 fSSDChipMedium(),
489 fSSDChipGlueMedium(),
490 fSSDStiffenerMedium(),
491 fSSDStiffenerConnectorMedium(),
492 fSSDStiffener0603CapacitorMedium(),
493 fSSDStiffener1812CapacitorMedium(),
494 fSSDStiffenerHybridWireMedium(),
495 fSSDKaptonFlexMedium(),
496 fSSDAlTraceFlexMedium(),
497 fSSDAlTraceLadderCableMedium(),
498 fSSDKaptonLadderCableMedium(),
499 fSSDKaptonChipCableMedium(),
500 fSSDAlTraceChipCableMedium(),
501 fSSDAlCoolBlockMedium(),
502 fSSDSensorMedium(),
503 fSSDSensorSupportMedium(),
504 fSSDCarbonFiberMedium(),
505 fSSDTubeHolderMedium(),
506 fSSDCoolingTubeWater(),
507 fSSDCoolingTubePhynox(),
9b0c60ab 508 fSSDSupportRingAl(),
44285dfa 509 fSSDMountingBlockMedium(),
bf210566 510 fSSDAir(),
511 fCreateMaterials(kFALSE),
512 fTransformationMatrices(kFALSE),
513 fBasicObjects(kFALSE),
514 fcarbonfiberjunction(),
515 fcoolingtubesupport(),
516 fhybridmatrix(),
517 fssdcoolingblocksystem(),
518 fcoolingblocksystematrix(),
519 fssdstiffenerflex(),
520 fssdendflex(),
9b0c60ab 521 fendladdercoolingtubesupportmatrix(),
bf210566 522 fendladdermountingblock(),
9b0c60ab 523 fendladdermountingblockclip(),
bf210566 524 fSSDSensor5(),
525 fSSDSensor6(),
526 fSSDLayer5(),
527 fSSDLayer6(),
528 fMotherVol(),
9b0c60ab 529 fLay5LadderSupportRing(),
530 fLay6LadderSupportRing(),
e5bf64ae 531 fgkEndCapSupportSystem(),
44285dfa 532 fColorCarbonFiber(4),
533 fColorRyton(5),
bf210566 534 fColorPhynox(14),
44285dfa 535 fColorSilicon(3),
bf210566 536 fColorAl(38),
44285dfa 537 fColorKapton(6),
538 fColorPolyhamide(5),
539 fColorStiffener(9),
bf210566 540 fColorEpoxy(30),
541 fColorWater(7),
542 fColorG10(41)
44285dfa 543{
544 ////////////////////////
545 // Standard constructor
546 ////////////////////////
44285dfa 547}
548/////////////////////////////////////////////////////////////////////////////////
549AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
9acf2ecc 550 AliITSv11Geometry(s.GetDebug()),
44285dfa 551 fSSDChipMedium(s.fSSDChipMedium),
552 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
553 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
554 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
555 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
556 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
557 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
558 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
559 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
560 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
561 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
562 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
563 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
564 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
565 fSSDSensorMedium(s.fSSDSensorMedium),
566 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
567 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
568 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
569 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
570 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
9b0c60ab 571 fSSDSupportRingAl(s.fSSDSupportRingAl),
44285dfa 572 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
bf210566 573 fSSDAir(s.fSSDAir),
574 fCreateMaterials(s.fCreateMaterials),
575 fTransformationMatrices(s.fTransformationMatrices),
576 fBasicObjects(s.fBasicObjects),
577 fcarbonfiberjunction(s.fcarbonfiberjunction),
578 fcoolingtubesupport(s.fcoolingtubesupport),
579 fhybridmatrix(s.fhybridmatrix),
580 fssdcoolingblocksystem(s.fssdcoolingblocksystem),
581 fcoolingblocksystematrix(s.fcoolingblocksystematrix),
582 fssdstiffenerflex(s.fssdstiffenerflex),
583 fssdendflex(s.fssdendflex),
9b0c60ab 584 fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
bf210566 585 fendladdermountingblock(s.fendladdermountingblock),
9b0c60ab 586 fendladdermountingblockclip(s.fendladdermountingblockclip),
bf210566 587 fSSDSensor5(s.fSSDSensor5),
588 fSSDSensor6(s.fSSDSensor6),
589 fSSDLayer5(s.fSSDLayer5),
590 fSSDLayer6(s.fSSDLayer6),
44285dfa 591 fMotherVol(s.fMotherVol),
9b0c60ab 592 fLay5LadderSupportRing(s.fLay5LadderSupportRing),
593 fLay6LadderSupportRing(s.fLay6LadderSupportRing),
e5bf64ae 594 fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
44285dfa 595 fColorCarbonFiber(s.fColorCarbonFiber),
596 fColorRyton(s.fColorRyton),
597 fColorPhynox(s.fColorPhynox),
598 fColorSilicon(s.fColorSilicon),
599 fColorAl(s.fColorAl),
600 fColorKapton(s.fColorKapton),
601 fColorPolyhamide(s.fColorPolyhamide),
602 fColorStiffener(s.fColorStiffener),
bf210566 603 fColorEpoxy(s.fColorEpoxy),
604 fColorWater(s.fColorWater),
605 fColorG10(s.fColorG10)
44285dfa 606{
607 ////////////////////////
608 // Copy Constructor
609 ////////////////////////
d7599219 610}
611/////////////////////////////////////////////////////////////////////////////////
44285dfa 612AliITSv11GeometrySSD& AliITSv11GeometrySSD::
613operator=(const AliITSv11GeometrySSD &s){
614 ////////////////////////
615 // Assignment operator
616 ////////////////////////
617 this->~AliITSv11GeometrySSD();
618 new(this) AliITSv11GeometrySSD(s);
619 return *this;
620/*
621 if(&s == this) return *this;
622 fMotherVol = s.fMotherVol;
623 return *this;
624 */
625}
bf210566 626///////////////////////////////////////////////////////////////////////////////
627void AliITSv11GeometrySSD::CreateTransformationMatrices(){
628 ///////////////////////////////////////////////////////////////////////
629 // Method generating the trasformation matrix for the whole SSD Geometry
630 ///////////////////////////////////////////////////////////////////////
631 // Setting some variables for Carbon Fiber Supportmatrix creation
632 //////////////////////////////////////////////////////////////////////
633 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
634 * CosD(fgkCarbonFiberJunctionAngle[0]);
635 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
636 + fgkCarbonFiberSupportTopEdgeDist[0]
637 + fgkCarbonFiberSupportWidth);
638 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
639 * TanD(fgkCarbonFiberJunctionAngle[0]);
640 TGeoRotation* carbonfiberot[3];
641 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
642 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
643 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
644 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
645 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
646 * CosD(fgkCarbonFiberTriangleAngle),0.,
647 - fgkCarbonFiberTriangleLength
648 * SinD(fgkCarbonFiberTriangleAngle)};
649 ///////////////////////////////////////////
650 //Setting Local Translations and Rotations:
651 ///////////////////////////////////////////
652 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
653 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
654 0.5*carbonfibersupportheight,NULL);
655 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
656 2.*symmetryplaneposition+transvector[1],
657 transvector[2], carbonfiberot[2]);
658 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
659 /////////////////////////////////////////////////////////////
660 // Carbon Fiber Support Transformations
661 /////////////////////////////////////////////////////////////
662 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
663 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
664 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
665 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
666 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
667 }
668 /////////////////////////////////////////////////////////////
669 // Carbon Fiber Junction Transformation
670 /////////////////////////////////////////////////////////////
671 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
672 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
673 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
674 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
675 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
676 localcarbonfiberjunctionmatrix[i] =
677 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
678 localcarbonfiberjunctionrot[i] =
679 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
680 localcarbonfiberjunctiontrans[i] =
681 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 682 }
bf210566 683 ///////////////////////
684 // Setting Translations
685 ///////////////////////
686 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
687 localcarbonfiberjunctiontrans[1][0] =
688 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
689 localcarbonfiberjunctiontrans[2][0] =
690 new TGeoTranslation(fgkCarbonFiberTriangleLength
691 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
692 fgkCarbonFiberTriangleLength
693 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
694 localcarbonfiberjunctiontrans[0][1] =
695 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
696 localcarbonfiberjunctiontrans[1][1] =
697 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
698 localcarbonfiberjunctiontrans[2][1] =
699 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
700 ////////////////////
701 // Setting Rotations
702 ////////////////////
703 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
704 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
705 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
706 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
707 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
708 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
709 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
710 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
711 ////////////////////////////////////////
712 // Setting Carbon Fiber Junction matrix
713 ////////////////////////////////////////
714 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
715 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
716 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
717 localcarbonfiberjunctionmatrix[i][j] =
718 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
719 *localcarbonfiberjunctionrot[i][j]);
720 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
721 }
d7599219 722 }
bf210566 723 /////////////////////////////////////////////////////////////
724 // Carbon Fiber Lower Support Transformations
725 /////////////////////////////////////////////////////////////
726 TGeoTranslation* localcarbonfiberlowersupportrans[2];
727 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
728 fgkCarbonFiberLowerSupportVolumePosition[1]
729 + fgkCarbonFiberLowerSupportVolumePosition[0],
730 0.0);
731 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
732 fgkCarbonFiberJunctionWidth
733 - fgkCarbonFiberLowerSupportWidth
734 - fgkCarbonFiberLowerSupportVolumePosition[0]
735 - fgkCarbonFiberLowerSupportVolumePosition[1],
736 - 0.5*fgkCarbonFiberLowerSupportHeight);
737 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
738 fcarbonfiberlowersupportrans[0] =
739 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
740 fcarbonfiberlowersupportrans[1] =
741 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
742 /////////////////////////////////////////////////////////////
743 // SSD Sensor Support Transformations
744 /////////////////////////////////////////////////////////////
745 const Int_t kssdsensorsupportmatrixnumber = 3;
746 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
747 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
748 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
749 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
750 localssdsensorsupportmatrix[i] =
751 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
752 localssdsensorsupportrot[i] =
753 new TGeoRotation*[kssdsensorsupportmatrixnumber];
754 localssdsensorsupportrans[i] =
755 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 756 }
bf210566 757 ///////////////////////
758 // Setting Translations
759 ///////////////////////
760 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
761 0.5*fgkSSDSensorSideSupportWidth,
762 0.0);
763 localssdsensorsupportrans[1][0] =
764 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
765 localssdsensorsupportrans[2][0] =
766 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
767 localssdsensorsupportrans[0][1] =
768 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
769 0.5*fgkSSDSensorSideSupportThickness[0],
770 0.0);
771 localssdsensorsupportrans[1][1] =
772 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
773 - 0.5*fgkSSDSensorSideSupportThickness[0]
774 - fgkSSDModuleSensorSupportDistance,
775 0.0);
776 localssdsensorsupportrans[2][1] =
777 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
778 - fgkSSDSensorCenterSupportPosition,
779 0.5*fgkSSDSensorCenterSupportWidth
780 - 0.5*fgkSSDModuleSensorSupportDistance,
781 fgkSSDSensorCenterSupportThickness[0]);
782 localssdsensorsupportrans[0][2] =
783 new TGeoTranslation(fgkCarbonFiberTriangleLength
784 + fgkCarbonFiberJunctionToSensorSupport,
785 fgkCarbonFiberJunctionWidth
786 - 0.5*(fgkCarbonFiberLowerSupportWidth
787 + fgkSSDSensorCenterSupportLength
788 - fgkSSDSensorCenterSupportThickness[0])
789 - fgkSSDSensorCenterSupportPosition,
790 0.0);
791 localssdsensorsupportrans[1][2] =
792 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
793 localssdsensorsupportrans[2][2] =
794 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
795 ////////////////////
796 // Setting Rotations
797 ////////////////////
798 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
799 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
800 localssdsensorsupportrot[i][j] = new TGeoRotation();
801 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
802 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
803 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 804 }
bf210566 805 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
806 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
807 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
808 ////////////////////////////////////////
809 // SSD Sensor Support matrix
810 ////////////////////////////////////////
811 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
812 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
813 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
814 localssdsensorsupportmatrix[i][j] =
815 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
816 *localssdsensorsupportrot[i][j]);
817 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
818 }
d7599219 819 }
44285dfa 820 /////////////////////////////////////////////////////////////
bf210566 821 // SSD Cooling Tube Support Transformations
44285dfa 822 /////////////////////////////////////////////////////////////
bf210566 823 const Int_t kcoolingtubesupportmatrixnumber = 2;
824 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
825 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
826 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 827 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 828 /fgkCoolingTubeSupportRmax);
bf210566 829 localcoolingtubesupportrans[0] =
830 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 831 + 2.*(fgkCoolingTubeSupportLength
44285dfa 832 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 833 + fgkCarbonFiberTriangleLength
bf210566 834 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
835 localcoolingtubesupportrans[1] =
836 new TGeoTranslation(fgkCarbonFiberJunctionLength
837 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
838 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
839 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
840 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
841 - 0.5*(fgkCarbonFiberLowerSupportWidth
842 + fgkSSDSensorCenterSupportLength
843 - fgkSSDSensorCenterSupportThickness[0])
844 + 0.5*fgkSSDSensorLength,
845 - 0.5*fgkCoolingTubeSupportHeight);
846 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
847 localcoolingtubesupportrot[i] = new TGeoRotation();
848 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
849 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
850 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
851 localcoolingtubesupportmatrix[i] =
852 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
853 *localcoolingtubesupportrot[i]);
854 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
855 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
856 (*localcoolingtubesupportmatrix[0]));
857 /////////////////////////////////////////////////////////////
9b0c60ab 858 // End Ladder SSD Cooling Tube Support Transformations
859 /////////////////////////////////////////////////////////////
860 TGeoTranslation** localendladdercooltubetrans[2];
861 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
862 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
863 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
864 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
865 - (fgkCoolingTubeSupportLength
866 - fgkCoolingTubeSupportRmax),
867 fgkEndLadderMountingBlockPosition[0]
868 - fgkendladdercoolingsupportdistance[0]
869 + 0.5*fgkCoolingTubeSupportWidth,
870 - 0.5*fgkCoolingTubeSupportHeight);
871 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
872 - (fgkCoolingTubeSupportLength
873 - fgkCoolingTubeSupportRmax),
874 fgkEndLadderMountingBlockPosition[0]
875 + fgkendladdercoolingsupportdistance[1]
876 + 0.5*fgkCoolingTubeSupportWidth,
877 - 0.5*fgkCoolingTubeSupportHeight);
878 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
879 - fgkCoolingTubeSupportRmax)
880 + fgkCarbonFiberTriangleLength
881 - 2.0*fgkCarbonFiberJunctionLength,
882 0.0,
883 0.0);
884 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
885 fgkendladdercoolingsupportdistance[0]
886 + fgkendladdercoolingsupportdistance[1],
887 0.0);
888 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
889 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
890 + fgkCarbonFiberJunctionLength
891 - fgkCoolingTubeSupportLength,
892 fgkEndLadderCarbonFiberLowerJunctionLength[1]
893 - 0.5*fgkCoolingTubeSupportWidth
894 -fgkendladdercoolingsupportdistance[2],
895 - 0.5*fgkCoolingTubeSupportHeight);
896 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
897 + fgkCoolingTubeSupportLength
898 - fgkCoolingTubeSupportRmax
899 - fgkCarbonFiberJunctionLength,
900 fgkEndLadderCarbonFiberLowerJunctionLength[1]
901 - 0.5*fgkCoolingTubeSupportWidth
902 - fgkendladdercoolingsupportdistance[2],
903 - 0.5*fgkCoolingTubeSupportHeight);
904 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
905 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
906 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
907 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
908 (*localcoolingtubesupportrot[1]));
909 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
910 (*localcoolingtubesupportrot[1]));
911 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
912 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
913 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
914 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
915 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
916
917 fendladdercoolingtubesupportmatrix[1][0] =
918 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
919 *(*localcoolingtubesupportrot[1]));
920 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
921 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
922 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
923 /////////////////////////////////////////////////////////////
bf210566 924 // SSD Cooling Tube Transformations
925 /////////////////////////////////////////////////////////////
926 TGeoRotation* localcoolingtuberot = new TGeoRotation();
927 localcoolingtuberot->SetAngles(0.,90.,0.);
928 TGeoTranslation** localcoolingtubetrans[4];
929 TVector3** localcoolingtubevect[4];
930 for(Int_t i=0; i<4; i++){
931 localcoolingtubevect[i] = new TVector3*[2];
932 localcoolingtubetrans[i] = new TGeoTranslation*[2];
933 fcoolingtubematrix[i] = new TGeoHMatrix*[2];
d7599219 934 }
bf210566 935 localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
936 -fgkCarbonFiberTriangleLength),
937 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
938 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
939 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
940 - 0.5*(fgkCarbonFiberLowerSupportWidth
941 + fgkSSDSensorCenterSupportLength
942 - fgkSSDSensorCenterSupportThickness[0])+
943 0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
944 - 2.0*fgkSSDModuleStiffenerPosition[1]
945 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
946 - 0.5*fgkCoolingTubeSupportWidth,
947 - 0.5*fgkCoolingTubeSupportHeight);
948 localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
949 localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
950 - 2.0*fgkSSDModuleStiffenerPosition[1]
951 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
952 + fgkCoolingTubeSupportWidth,
953 localcoolingtubevect[0][0]->Z());
954 localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
955 + fgkCarbonFiberTriangleLength,
956 localcoolingtubevect[0][0]->Y(),
957 localcoolingtubevect[0][0]->Z());
958 localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
959 + fgkCarbonFiberTriangleLength,
960 localcoolingtubevect[0][1]->Y(),
961 localcoolingtubevect[0][1]->Z());
962 localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
963 - fgkCarbonFiberTriangleLength),
964 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
965 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
966 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
967 - 0.5*(fgkCarbonFiberLowerSupportWidth
968 + fgkSSDSensorCenterSupportLength
969 - fgkSSDSensorCenterSupportThickness[0])
970 + fgkSSDModuleStiffenerPosition[1]
971 - 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
972 - 0.5*fgkCoolingTubeSupportHeight);
973 localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
974 + fgkCarbonFiberTriangleLength,
975 localcoolingtubevect[2][0]->Y(),
976 localcoolingtubevect[2][0]->Z());
977 localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
978 - fgkCarbonFiberTriangleLength),
979 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
980 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
981 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
982 - 0.5*(fgkCarbonFiberLowerSupportWidth
983 + fgkSSDSensorCenterSupportLength
984 - fgkSSDSensorCenterSupportThickness[0])
985 + fgkSSDSensorLength
986 - 0.5*fgkSSDModuleStiffenerPosition[1],
987 - 0.5*fgkCoolingTubeSupportHeight);
988 localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
989 + fgkCarbonFiberTriangleLength,
990 localcoolingtubevect[3][0]->Y(),
991 - 0.5*fgkCoolingTubeSupportHeight);
992 for(Int_t i=0; i<4; i++)
993 for(Int_t j=0; j<2; j++){
994 localcoolingtubetrans[i][j] =
995 new TGeoTranslation(localcoolingtubevect[i][j]->X(),
996 localcoolingtubevect[i][j]->Y(),
997 localcoolingtubevect[i][j]->Z());
998 fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
999 * (*localcoolingtuberot));
1000 }
1001 /////////////////////////////////////////////////////////////
9b0c60ab 1002 // SSD End Ladder Cooling Tube Transformations
1003 /////////////////////////////////////////////////////////////
1004 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1005 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1006 TGeoTranslation** localendlladdercoolingtubetrans[2];
1007 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
1008 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
1009 for(Int_t i=0; i<2; i++)
1010 for(Int_t j=0; j<(i==0?6:4); j++)
1011 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1012 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1013 - fgkCoolingTubeSupportRmax)
1014 + fgkCarbonFiberJunctionLength,
1015 0.5*(fgkEndLadderMountingBlockPosition[0]
1016 - fgkendladdercoolingsupportdistance[0]),
1017 - 0.5*fgkCoolingTubeSupportHeight);
1018 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1019 - fgkCoolingTubeSupportRmax)
1020 - fgkCarbonFiberJunctionLength
1021 + fgkCarbonFiberTriangleLength,
1022 0.5*(fgkEndLadderMountingBlockPosition[0]
1023 - fgkendladdercoolingsupportdistance[0]),
1024 - 0.5*fgkCoolingTubeSupportHeight);
1025 localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1026 - fgkCoolingTubeSupportRmax)
1027 + fgkCarbonFiberJunctionLength,
1028 fgkEndLadderMountingBlockPosition[0]
1029 - fgkendladdercoolingsupportdistance[0]
1030 + 0.5*(fgkendladdercoolingsupportdistance[0]
1031 + fgkendladdercoolingsupportdistance[1]
1032 + fgkCoolingTubeSupportWidth),
1033 - 0.5*fgkCoolingTubeSupportHeight);
1034 localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
1035 - fgkCoolingTubeSupportRmax)
1036 - fgkCarbonFiberJunctionLength
1037 + fgkCarbonFiberTriangleLength,
1038 fgkEndLadderMountingBlockPosition[0]
1039 - fgkendladdercoolingsupportdistance[0]
1040 + 0.5*(fgkendladdercoolingsupportdistance[0]
1041 + fgkendladdercoolingsupportdistance[1]
1042 + fgkCoolingTubeSupportWidth),
1043 - 0.5*fgkCoolingTubeSupportHeight);
1044 localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
1045 - fgkCoolingTubeSupportRmax)
1046 + fgkCarbonFiberJunctionLength,
1047 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1048 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1049 - fgkEndLadderMountingBlockPosition[0]
1050 - fgkendladdercoolingsupportdistance[1]
1051 - fgkCoolingTubeSupportWidth),
1052 - 0.5*fgkCoolingTubeSupportHeight);
1053 localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
1054 - fgkCoolingTubeSupportRmax)
1055 - fgkCarbonFiberJunctionLength
1056 + fgkCarbonFiberTriangleLength,
1057 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1058 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1059 - fgkEndLadderMountingBlockPosition[0]
1060 - fgkendladdercoolingsupportdistance[1]
1061 - fgkCoolingTubeSupportWidth),
1062 - 0.5*fgkCoolingTubeSupportHeight);
1063 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1064 - fgkCoolingTubeSupportRmax)
1065 + fgkCarbonFiberJunctionLength,
1066 - 0.50 * (fgkMountingBlockToSensorSupport
1067 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1068 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1069 + fgkSSDSensorOverlap
1070 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1071 - fgkendladdercoolingsupportdistance[2]
1072 - fgkEndLadderMountingBlockPosition[1]
1073 - fgkCoolingTubeSupportWidth)
1074 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1075 - fgkendladdercoolingsupportdistance[2]
1076 - fgkCoolingTubeSupportWidth,
1077 - 0.5*fgkCoolingTubeSupportHeight);
1078 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1079 - fgkCoolingTubeSupportRmax)
1080 - fgkCarbonFiberJunctionLength
1081 + fgkCarbonFiberTriangleLength,
1082 - 0.50 * (fgkMountingBlockToSensorSupport
1083 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1084 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1085 + fgkSSDSensorOverlap
1086 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1087 - fgkendladdercoolingsupportdistance[2]
1088 - fgkEndLadderMountingBlockPosition[1]
1089 - fgkCoolingTubeSupportWidth)
1090 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1091 - fgkendladdercoolingsupportdistance[2]
1092 - fgkCoolingTubeSupportWidth,
1093 - 0.5*fgkCoolingTubeSupportHeight);
1094 localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1095 - fgkCoolingTubeSupportRmax)
1096 + fgkCarbonFiberJunctionLength,
1097 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1098 - 0.5*fgkendladdercoolingsupportdistance[2],
1099 - 0.5*fgkCoolingTubeSupportHeight);
1100 localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
1101 - fgkCoolingTubeSupportRmax)
1102 - fgkCarbonFiberJunctionLength
1103 + fgkCarbonFiberTriangleLength,
1104 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1105 - 0.5*fgkendladdercoolingsupportdistance[2],
1106 - 0.5*fgkCoolingTubeSupportHeight);
1107 fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
1108 fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
1109 for(Int_t i=0; i<2; i++)
1110 for(Int_t j=0; j<(i==0?6:4); j++){
1111 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1112 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1113 }
1114 /////////////////////////////////////////////////////////////
bf210566 1115 // SSD Hybrid Components Transformations
1116 /////////////////////////////////////////////////////////////
1117 const Int_t khybridmatrixnumber = 3;
1118 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1119 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1120 0.5*fgkSSDStiffenerWidth,
1121 0.5*fgkSSDStiffenerHeight);
1122 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1123 fgkSSDModuleStiffenerPosition[1],0.0);
1124
1125 localhybridtrans[2] = new TGeoTranslation(
1126 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1127 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1128 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1129 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1130 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1131 - fgkSSDSensorCenterSupportThickness[0]),
1132 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1133 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight));
1134 fhybridmatrix = new TGeoHMatrix();
1135 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1136 /////////////////////////////////////////////////////////////
1137 // SSD Cooling Block Transformations
1138 /////////////////////////////////////////////////////////////
1139 const Int_t kcoolingblockmatrixnumber = 4;
1140 TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
1141 localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
1142 - fgkCoolingTubeSupportRmin),0.0,
1143 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1144 localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
1145 - 0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
1146 0.0,fgkSSDStiffenerHeight);
1147 localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
1148 localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
1149 fcoolingblocksystematrix = new TGeoHMatrix();
1150 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
1151 fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
1152 /////////////////////////////////////////////////////////////
1153 // SSD Stiffener Flex Transformations
1154 /////////////////////////////////////////////////////////////
1155 const Int_t klocalflexmatrixnumber = 4;
1156 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1157 for(Int_t i=0; i<fgkflexnumber; i++)
1158 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1159 for(Int_t i=0; i<fgkflexnumber; i++)
1160 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1161 localflexmatrix[i][j] = new TGeoCombiTrans();
1162 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1163 - 2.*fgkSSDModuleStiffenerPosition[1]
1164 - fgkSSDStiffenerWidth;
1165 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1166 +0.5*fgkSSDStiffenerLength,
1167 0.5*fgkSSDStiffenerWidth,
1168 -0.5*fgkSSDStiffenerHeight
1169 -0.5*fgkSSDFlexHeight[0]);
1170 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1171 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1172 -0.5*fgkSSDStiffenerWidth,
1173 -0.5*fgkSSDStiffenerHeight
1174 -0.5*fgkSSDFlexHeight[0]);
1175 TGeoRotation* localflexrot = new TGeoRotation();
1176 localflexrot->SetAngles(180.,0.,0.);
1177 localflexmatrix[1][0]->SetRotation(localflexrot);
1178 for(Int_t i=0; i<fgkflexnumber; i++)
1179 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1180 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1181 for(Int_t i=0; i<fgkflexnumber; i++){
1182 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1183 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1184 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1185 }
bf210566 1186 /////////////////////////////////////////////////////////////
1187 // SSD End Flex Transformations
1188 /////////////////////////////////////////////////////////////
1189 TGeoRotation* localendflexrot = new TGeoRotation();
1190 localendflexrot->SetAngles(0.0,90.0,0.0);
1191 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1192 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1193 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1194 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1195 * TMath::DegToRad()*ssdflexradiusmax
1196 - fgkSSDFlexLength[2]-TMath::Pi()
1197 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
1198 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1199 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1200 + fgkSSDFlexLength[2];
1201 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1202 0.5*fgkSSDFlexWidth[0],
1203 2.*fgkSSDStiffenerHeight
1204 + 0.5*fgkSSDFlexHeight[0]);
1205 localendflexmatrix->SetRotation(localendflexrot);
1206 for(Int_t i=0; i<fgkflexnumber; i++)
1207 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1208 /////////////////////////////////////////////////////////////
1209 // End Ladder Carbon Fiber Junction
1210 /////////////////////////////////////////////////////////////
1211 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1212 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1213 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1214 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1215 localendladdercarbonfiberjunctionmatrix[i]
1216 = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1217 localendladdercarbonfiberjunctionrot[i]
1218 = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1219 localendladdercarbonfiberjunctiontrans[i]
1220 = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1221 fendladdercarbonfiberjunctionmatrix[i]
1222 = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
d7599219 1223 }
bf210566 1224 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1225 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1226 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1227 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1228 }
1229 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1230 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1231 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1232 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1233 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1234 0.0,0.0);
1235 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1236 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1237 * SinD(fgkCarbonFiberTriangleAngle),
1238 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1239 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1240 }
1241 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1242 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1243 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1244 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1245 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1246 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1247 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1248 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1249 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1250 localendladdercarbonfiberjunctionglobalmatrix[i] =
1251 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1252 *localendladdercarbonfiberjunctionglobalrot[i]);
1253 }
1254 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1255 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1256 localendladdercarbonfiberjunctionmatrix[i][j] =
1257 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1258 *localendladdercarbonfiberjunctionrot[i][j]);
1259 fendladdercarbonfiberjunctionmatrix[i][j] =
1260 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1261 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1262 }
1263 /////////////////////////////////////////////////////////////
1264 // End Ladder Carbon Fiber Support
1265 /////////////////////////////////////////////////////////////
1266 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1267 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1268 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1269 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1270 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1271 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1272 }
1273 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1274 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1275 fendladdercarbonfibermatrix[i][j] =
1276 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1277 *(*fcarbonfibersupportmatrix[j]));
1278 /////////////////////////////////////////////////////////////
1279 // End Ladder SSD Mounting Block
1280 /////////////////////////////////////////////////////////////
1281 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1282 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1283 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1284 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1285 + fgkSSDMountingBlockLength[1])
1286 + 0.5*fgkCarbonFiberTriangleLength,
1287 fgkEndLadderMountingBlockPosition[i],
1288 - fgkSSDMountingBlockHeight[1]
1289 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1290 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1291 endladdermountingblockrot->SetAngles(0.,90.,0.);
1292 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1293 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1294 /////////////////////////////////////////////////////////////
1295 // End Ladder SSD Mounting Block Clip Matrix
1296 /////////////////////////////////////////////////////////////
1297 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1298 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1299
1300 TGeoRotation* localendladdercliprot = new TGeoRotation();
1301 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1302 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1303 - fgkSSDMountingBlockLength[1])
1304 + fgkSSDMountingBlockLength[0],0.,0.);
1305 localendladdercliprot->SetAngles(90.,180.,-90.);
1306 TGeoCombiTrans* localendladderclipcombitrans =
1307 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1308 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1309 for(Int_t j=0; j<2; j++){
1310 fendladdermountingblockclipmatrix[i][j] =
1311 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1312 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1313 }
bf210566 1314 /////////////////////////////////////////////////////////////
1315 // End Ladder Carbon Fiber Lower Support
1316 /////////////////////////////////////////////////////////////
1317 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1318 fendladderlowersupptrans[i] =
1319 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1320 + 0.5*fgkSSDMountingBlockWidth),
1321 - 0.5*fgkCarbonFiberLowerSupportHeight);
1322 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1323 fgkCarbonFiberLowerSupportVolumePosition[1]
1324 + fgkCarbonFiberLowerSupportVolumePosition[0],
1325 0.0);
1326 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1327 /////////////////////////////////////////////////////////////
1328 // Matrix for positioning Ladder into mother volume
1329 /////////////////////////////////////////////////////////////
1330 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1331 for(Int_t i=0; i<fgkladdernumber; i++)
1332 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1333 TGeoRotation* localladdermotherrot = new TGeoRotation();
1334 localladdermotherrot->SetAngles(0.,90.,0.);
1335 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1336 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1337 for(Int_t i=0; i<fgkladdernumber; i++){
1338 localladdermothertrans[i] = new TGeoTranslation(0.,
1339 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1340 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1341 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1342 * fgkCarbonFiberJunctionWidth,0.);
1343 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1344 *localladdermotherrot);
1345 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1346 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1347 }
44285dfa 1348 /////////////////////////////////////////////////////////////
bf210566 1349 // Ladder Cables Matrices
44285dfa 1350 /////////////////////////////////////////////////////////////
44285dfa 1351 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1352 + fgkSSDFlexHeight[1];
44285dfa 1353 Double_t ssdladdercabletransx[3];
1354 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1355 * SinD(2.*fgkSSDFlexAngle)
1356 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1357 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1358 - ssdladdercabletransx[0]
bf210566 1359 / SinD(2.*fgkSSDFlexAngle))
1360 * CosD(fgkSSDFlexAngle);
44285dfa 1361 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1362 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1363 - fgkSSDFlexLength[2]-TMath::Pi()
1364 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1365 - fgkSSDLadderCableWidth)
bf210566 1366 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1367 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1368 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1369 ssdladdercabletransx[1]
bf210566 1370 * TanD(fgkSSDFlexAngle),
44285dfa 1371 ssdladdercabletransx[2]
bf210566 1372 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1373 TGeoRotation* localladdercablerot[3];
bf210566 1374 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1375 localladdercablerot[0]->SetAngles(90.,0.,0.);
1376 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1377 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1378 * (*localladdercablerot[0]));
1379 ////////////////////////////////////////////
1380 // LocalLadderCableCombiTransMatrix
1381 ////////////////////////////////////////////
1382 const Int_t klocalladdersidecablesnumber = 2;
1383 const Int_t klocalladdercombitransnumber = 5;
1384 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1385 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1386 localladdercablecombitransmatrix[i] =
1387 new TGeoCombiTrans*[klocalladdercombitransnumber];
1388 ///////////////////////////////////////////
1389 // Left Side Ladder Cables Transformations
1390 ///////////////////////////////////////////
1391 localladdercablecombitransmatrix[0][0] =
d7599219 1392 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1393 0.,0.,NULL);
bf210566 1394 localladdercablecombitransmatrix[0][1] =
1395 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1396 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1397 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1398 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1399 - 0.5*(fgkCarbonFiberLowerSupportWidth
1400 + fgkSSDSensorCenterSupportLength
1401 - fgkSSDSensorCenterSupportThickness[0]),
1402 - (fgkSSDModuleCoolingBlockToSensor
1403 + 0.5*fgkCoolingTubeSupportHeight
1404 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1405 - fgkSSDChipHeight),NULL);
44285dfa 1406 localladdercablecombitransmatrix[0][2] =
d7599219 1407 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1408 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1409 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1410 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1411 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1412 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1413 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1414 new TGeoRotation("",180.,0.,0.));
44285dfa 1415 localladdercablecombitransmatrix[0][4] =
1416 new TGeoCombiTrans(-ssdladdercabletransx[0]
1417 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1418 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1419 0.,
1420 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1421 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1422 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1423 + ssdladdercabletransz[2],localladdercablerot[2]);
1424 ///////////////////////////////////////////
1425 // Rigth Side Ladder Cables Transformations
1426 ///////////////////////////////////////////
bf210566 1427 TGeoCombiTrans* localladdercablessdmodulematrix =
1428 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1429 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1430 fgkSSDStiffenerWidth,
1431 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1432 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1433 localladdercablecombitransmatrix[1][i] =
bf210566 1434 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1435 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1436 ///////////////////////////////////////////
bf210566 1437 // Setting LadderCableHMatrix
44285dfa 1438 ///////////////////////////////////////////
bf210566 1439 Int_t beamaxistrans[2][3];
1440 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1441 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1442 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1443 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1444 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1445 beamaxistrans[1][2] = beamaxistrans[1][0];
1446 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1447 TGeoRotation* laddercablerot = new TGeoRotation();
1448 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1449 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1450 Double_t* laddercabletransvector;
1451 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1452 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1453 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1454 }
1455 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1456 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1457 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1458 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1459 localladdercablehmatrix[i][j]->MultiplyLeft(
1460 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1461 }
1462 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1463 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1464 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1465 laddercabletransvector[1]
bf210566 1466 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1467 * fgkCarbonFiberJunctionWidth,
bf210566 1468 laddercabletransvector[2]);
1469 laddercablecombitrans->SetRotation(*laddercablerot);
1470 laddercablecombitrans->SetTranslation(*laddercabletrans);
1471 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1472 }
1473 fladdercablematrix[i][2] =
1474 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1475 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1476 fladdercablematrix[i][3] =
1477 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1478 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1479 }
1480 for(Int_t i=0; i<fgkladdercablesnumber; i++)
1481 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1482 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1483 ///////////////////////////////////////////
1484 // Setting Ladder HMatrix
1485 ///////////////////////////////////////////
1486 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1487 fgkSSDLay6SensorsNumber};
1488 for(Int_t i=0; i<fgkladdernumber; i++){
1489 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1490 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1491 fladdermatrix[i][j] = new TGeoHMatrix();
1492 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1493 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1494 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1495 }
1496 }
1497 ///////////////////////////////////////////
1498 // Setting SSD Sensor Matrix
1499 ///////////////////////////////////////////
1500 TGeoCombiTrans* localssdsensorcombitrans[2];
1501 TGeoRotation* localssdsensorrot = new TGeoRotation();
1502 localssdsensorrot->SetAngles(0.,90.,0.);
1503 TGeoTranslation* localssdsensortrans[2];
1504 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1505 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1506 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1507 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1508 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1509 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1510 - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1511 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1512 - fgkSSDModuleCoolingBlockToSensor+(fgkSSDSensorSideSupportHeight[1]
1513 - fgkSSDSensorSideSupportHeight[0]));
1514 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1515 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1516 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1517 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1518 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1519 - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1520 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1521 -fgkSSDModuleCoolingBlockToSensor);
1522 for(Int_t i=0; i<2; i++)
1523 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1524 *localssdsensorrot);
1525 for(Int_t i=0; i<fgkladdernumber; i++){
1526 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1527 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1528 switch(i){
1529 case 0: //Ladder of Layer5
1530 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1531 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1532 *localssdsensorcombitrans[1])));
1533 break;
1534 case 1: //Ladder of Layer6
1535 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1536 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1537 *localssdsensorcombitrans[0])));
1538 break;
1539 }
1540 }
1541 }
1542 //////////////////////////
1543 // Setting SSD End Ladder
1544 //////////////////////////
1545 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1546 for(Int_t i=0; i<2; i++){
1547 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1548 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1549 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1550 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1551 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1552 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1553 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1554 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1555 }
1556 /////////////////////////////////////////////////////
1557 // Setting the CombiTransformation to pass ITS center
1558 /////////////////////////////////////////////////////
1559 Double_t itscentertransz[fgklayernumber];
1560 itscentertransz[0] = fgkSSDLay5LadderLength
1561 - fgkLay5CenterITSPosition;
1562 itscentertransz[1] = fgkSSDLay6LadderLength
1563 - fgkLay6CenterITSPosition;
1564 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1565 + 0.5*fgkCoolingTubeSupportHeight;
1566 TGeoRotation* itscenterrot[3];
1567 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1568 itscenterrot[0]->SetAngles(90.,180.,-90.);
1569 itscenterrot[1]->SetAngles(0.,90.,0.);
1570 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1571 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1572 for(Int_t i=0; i<fgklayernumber; i++)
1573 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1574 itssensortransy,
1575 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1576 - itscentertransz[i],itscenterrot[2]);
1577 TGeoRotation** locallayerrot[fgklayernumber];
1578 TGeoTranslation** locallayertrans[fgklayernumber];
1579 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1580 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1581 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1582 - fgkLay5CenterITSPosition);
1583 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1584 - fgkLay6CenterITSPosition);
1585 const Int_t kssdlayladdernumber[fgklayernumber] =
1586 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1587 for(Int_t i=0; i<fgklayernumber; i++){
1588 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1589 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1590 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1591 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1592 }
1593 Double_t layerladderangleposition[fgklayernumber] =
1594 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1595 Double_t layerradius = 0.;
1596 for(Int_t i=0; i<fgklayernumber; i++){
1597 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1598 switch(i){
1599 case 0: //Ladder of Layer5
1600 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1601 break;
1602 case 1: //Ladder of Layer6
1603 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1604 break;
1605 }
1606 locallayerrot[i][j] = new TGeoRotation();
1607 locallayertrans[i][j] = new TGeoTranslation();
1608 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1609 locallayertrans[i][j]->SetTranslation(layerradius
1610 * CosD(90.0+j*layerladderangleposition[i]),
1611 layerradius
1612 * SinD(90.0+j*layerladderangleposition[i]),0.);
1613 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1614 *locallayerrot[i][j]);
1615 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1616 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1617 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1618 }
1619 }
44285dfa 1620 /////////////////////////////////////////////////////////////
bf210566 1621 // Deallocating memory
44285dfa 1622 /////////////////////////////////////////////////////////////
bf210566 1623 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1624 delete carbonfiberot[i];
1625 delete localcarbonfibersupportmatrix[i];
1626 }
1627 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1628 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1629 delete localcarbonfiberjunctionmatrix[i][j];
1630 delete localcarbonfiberjunctionrot[i][j];
1631 delete localcarbonfiberjunctiontrans[i][j];
1632 }
1633 delete [] localcarbonfiberjunctionmatrix[i];
1634 delete [] localcarbonfiberjunctionrot[i];
1635 delete [] localcarbonfiberjunctiontrans[i];
1636 }
1637 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1638 delete localcarbonfiberlowersupportrans[i];
1639 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1640 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1641 delete localssdsensorsupportmatrix[i][j];
1642 delete localssdsensorsupportrot[i][j];
1643 delete localssdsensorsupportrans[i][j];
1644 }
1645 delete [] localssdsensorsupportmatrix[i];
1646 delete [] localssdsensorsupportrot[i];
1647 delete [] localssdsensorsupportrans[i];
1648 }
1649 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1650 delete localcoolingtubesupportmatrix[i];
1651 delete localcoolingtubesupportrot[i];
1652 delete localcoolingtubesupportrans[i];
1653 }
1654 for(Int_t i=0; i<4; i++){
1655 for(Int_t j=0; j<2; j++){
1656 delete localcoolingtubevect[i][j];
1657 delete localcoolingtubetrans[i][j];
1658 }
1659 delete [] localcoolingtubevect[i];
1660 delete [] localcoolingtubetrans[i];
1661 }
9b0c60ab 1662 delete endladdermountingblockrot;
bf210566 1663 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1664 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
1665 for(Int_t i=0; i<fgkflexnumber; i++){
1666 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1667 delete localflexmatrix[i][j];
1668 delete [] localflexmatrix[i];
1669 }
9b0c60ab 1670 delete localendlladdercoolingtuberot;
1671 for(Int_t i=0; i<2; i++){
1672 for(Int_t j=0; j<(i==0?6:4); j++)
1673 delete localendlladdercoolingtubetrans[i][j];
1674 delete [] localendlladdercoolingtubetrans[i];
1675 }
1676
bf210566 1677 delete localflexrot;
1678 delete localendflexrot;
1679 delete localendflexmatrix;
1680 for(Int_t i=0; i<fgkladdernumber; i++){
1681 delete localladdermothertrans[i];
1682 delete localladdermothercombitrans[i];
1683 }
1684 delete localladdermotherrot;
1685 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1686 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1687 delete localendladdercarbonfiberjunctionmatrix[i][j];
1688 delete localendladdercarbonfiberjunctionrot[i][j];
1689 delete localendladdercarbonfiberjunctiontrans[i][j];
1690 }
1691 delete [] localendladdercarbonfiberjunctionmatrix[i];
1692 delete [] localendladdercarbonfiberjunctionrot[i];
1693 delete [] localendladdercarbonfiberjunctiontrans[i];
1694 delete localendladdercarbonfiberjunctionglobalrot[i];
1695 delete localendladdercarbonfiberjunctionglobaltrans[i];
1696 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1697 }
9b0c60ab 1698 for(Int_t i=0; i<2; i++){
1699 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1700 delete [] localendladdercooltubetrans[i];
1701 }
1702 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1703 delete localendladdercarbonfibertrans[i];
1704 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1705 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1706 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1707 delete localladdercablecombitransmatrix[i][j];
1708 delete []localladdercablecombitransmatrix[i];
1709 }
9b0c60ab 1710 delete localendladdercliprot;
1711 delete localendladdercliptrans;
bf210566 1712 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1713 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1714 delete localladdercablehmatrix[i][j];
1715 delete []localladdercablehmatrix[i];
1716 }
1717 delete laddercablerot;
1718 delete laddercabletrans;
1719 delete laddercablecombitrans;
1720 delete localladdercablessdmodulematrix;
1721 delete localssdsensorrot;
1722 for(Int_t i=0; i<2; i++){
1723 delete localssdsensortrans[i];
1724 delete localssdsensorcombitrans[i];
1725 }
1726 for(Int_t i=0; i<fgklayernumber; i++){
1727 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1728 delete locallayerrot[i][j];
1729 delete locallayertrans[i][j];
1730 delete locallayercombitrans[i][j];
1731 }
1732 delete [] locallayerrot[i];
1733 delete [] locallayertrans[i];
1734 delete [] locallayercombitrans[i];
1735 delete localbeamaxistrans[i];
1736 }
1737 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1738 for(Int_t i=0; i<fgkladdernumber; i++){
1739 for(Int_t j=0; j<fgkladdernumber; j++)
1740 delete ladderglobalmatrix[i][j];
1741 delete [] ladderglobalmatrix[i];
1742 }
1743 /////////////////////////////////////////////////////////////
1744 fTransformationMatrices = kTRUE;
d7599219 1745}
bf210566 1746///////////////////////////////////////////////////////////////////////////////
1747void AliITSv11GeometrySSD::CreateBasicObjects(){
1748 /////////////////////////////////////////////////////////////
1749 // Method generating the Objects of SSD Geometry
1750 /////////////////////////////////////////////////////////////
1751 // SSD Sensor
1752 ///////////////////////////////////
1753 SetSSDSensor();
1754 /////////////////////////////////////////////////////////////
1755 // Carbon Fiber Support
1756 /////////////////////////////////////////////////////////////
1757 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1758 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1759 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1760 /////////////////////////////////////////////////////////////
bf210566 1761 // Carbon Fiber Junction
44285dfa 1762 /////////////////////////////////////////////////////////////
bf210566 1763 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
1764 /////////////////////////////////////////////////////////////
1765 // Carbon Fiber Lower Support
1766 /////////////////////////////////////////////////////////////
1767 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1768 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1769 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1770 /////////////////////////////
1771 // SSD Sensor Support
1772 /////////////////////////////
1773 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1774 new TGeoVolume*[fgkssdsensorsupportnumber];
44285dfa 1775 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
bf210566 1776 fgkSSDSensorSideSupportThickness[1]};
1777 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1778 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1779 fgkSSDSensorSideSupportHeight[i],
1780 fgkSSDSensorSideSupportWidth,
1781 sidesupporthickness);
1782 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1783 fgkSSDSensorCenterSupportHeight[i],
1784 fgkSSDSensorCenterSupportWidth,
1785 sidesupporthickness);
1786 }
1787 /////////////////////////////////////////////////////////////
1788 // SSD Cooling Tube Support
1789 /////////////////////////////////////////////////////////////
1790 Int_t edgesnumber = 16;
1791 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1792 /////////////////////////////////////////////////////////////
1793 // SSD Hybrid
1794 /////////////////////////////////////////////////////////////
1795 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1796 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1797 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1798 /////////////////////////////////////////////////////////////
1799 // SSD Cooling Block System
1800 /////////////////////////////////////////////////////////////
1801 fssdcoolingblocksystem = GetCoolingBlockSystem();
1802 /////////////////////////////////////////////////////////////
1803 // SSD Cooling Tube
1804 /////////////////////////////////////////////////////////////
1805 TList* coolingtubelist = GetCoolingTubeList();
1806 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
1807 fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
9b0c60ab 1808 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
1809 fendladdercoolingtube[i] =
1810 (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
bf210566 1811 /////////////////////////////////////////////////////////////
1812 // SSD Flex
1813 /////////////////////////////////////////////////////////////
1814 fssdstiffenerflex = GetSSDStiffenerFlex();
1815 fssdendflex = GetSSDEndFlex();
1816 ///////////////////////////////////
1817 // End Ladder Carbon Fiber Junction
1818 ///////////////////////////////////
1819 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1820 fendladdercarbonfiberjunction[i] =
1821 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1822 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1823 fendladdercarbonfiberjunction[i][0] =
1824 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
1825 fendladdercarbonfiberjunction[i][1] =
1826 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
1827 }
1828 ///////////////////////////////////
1829 // End Ladder Mounting Block
1830 ///////////////////////////////////
1831 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1832 ///////////////////////////////////
1833 // End Ladder Mounting Block
1834 ///////////////////////////////////
1835 fendladdermountingblockclip = GetMountingBlockClip();
1836 ///////////////////////////////////
1837 // Ladder Support
1838 ///////////////////////////////////
1839 TList* laddersupportlist = GetMountingBlockSupport(20);
1840 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1841 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1842 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1843 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
bf210566 1844 /////////////////////////////////////////////////////////////
1845 // Deallocating memory
44285dfa 1846 /////////////////////////////////////////////////////////////
bf210566 1847 delete carbonfibersupportlist;
1848 delete carbonfiberlowersupportlist;
1849 delete ssdhybridcomponentslist;
9b0c60ab 1850 delete laddersupportlist;
44285dfa 1851 /////////////////////////////////////////////////////////////
bf210566 1852 fBasicObjects = kTRUE;
1853}
1854/////////////////////////////////////////////////////////////////////////////////
1855void AliITSv11GeometrySSD::SetSSDSensor(){
1856 ////////////////////////////////////////////////////////////////
1857 // Method generating SSD Sensors: it sets the private variables
1858 // fSSDSensor5, fSSDSensor6
1859 ////////////////////////////////////////////////////////////////
44285dfa 1860 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1861 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1862 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
44285dfa 1863 0.5*ssdsensitivewidth,
bf210566 1864 0.5*fgkSSDSensorHeight,
1865 0.5*ssdsensitivelength);
1866 TGeoVolume* ssdsensorsensitiveLay5 =
1867 new TGeoVolume(fgSDDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
1868 TGeoVolume* ssdsensorsensitiveLay6 =
1869 new TGeoVolume(fgSDDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
1870 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1871 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
44285dfa 1872 TGeoBBox* ssdsensorinsensitiveshape[2];
1873 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1874 0.5*fgkSSDSensorInsensitiveWidth,
bf210566 1875 0.5*fgkSSDSensorHeight,
1876 0.5*fgkSSDSensorLength);
44285dfa 1877 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
44285dfa 1878 0.5*ssdsensitivewidth,
bf210566 1879 0.5*fgkSSDSensorHeight,
1880 0.5*fgkSSDSensorInsensitiveWidth);
44285dfa 1881 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1882 "SSDSensorInsensitive2"};
44285dfa 1883 TGeoVolume* ssdsensorinsensitive[2];
1884 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1885 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1886 fSSDSensorMedium);
1887 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1888 }
bf210566 1889 /////////////////////////////////////////////////////////////
1890 // Virtual Volume containing SSD Sensor
1891 /////////////////////////////////////////////////////////////
1892 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1893 0.5*fgkSSDSensorWidth,
1894 0.5*fgkSSDSensorHeight,
1895 0.5*fgkSSDSensorLength);
1896 fSSDSensor5 = new TGeoVolume("ITSsddSensor5",virtualSSDSensorShape,
1897 fSSDAir);
1898 fSSDSensor6 = new TGeoVolume("ITSsddSensor6",virtualSSDSensorShape,
1899 fSSDAir);
1900 /////////////////////////////////////////////////////////////
1901 for(Int_t i=0; i<4; i++){
1902 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1903 ssdsensorinsensitive[1],i<2?1:2,
1904 new TGeoTranslation(
1905 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1906 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1907 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1908 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1909 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
44285dfa 1910 ssdsensorinsensitive[1],i<2?1:2,
bf210566 1911 new TGeoTranslation(
1912 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1913 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1914 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1915 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1916 }
1917 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1918 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1919}
bf210566 1920///////////////////////////////////////////////////////////////////////////////
1921TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1922 /////////////////////////////////////////////////////////////
1923 // Method generating the Carbon Fiber Support
1924 /////////////////////////////////////////////////////////////
1925 const Int_t kvertexnumber = 4;
1926 const Int_t kshapesnumber = 2;
1927 TVector3** vertexposition[kshapesnumber];
1928 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1929 Double_t carbonfibersupportxaxisEdgeproj =
1930 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1931 * TMath::DegToRad());
1932 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1933 / fgkCarbonFiberSupportXAxisLength);
1934 /////////////////////
1935 //Vertex Positioning
1936 ////////////////////
1937 vertexposition[0][0] = new TVector3();
1938 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1939 fgkCarbonFiberSupportYAxisLength);
1940 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1941 carbonfibersupportxaxisEdgeproj
1942 * TMath::Tan(theta));
1943 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1944 - carbonfibersupportxaxisEdgeproj,
1945 fgkCarbonFiberSupportYAxisLength
1946 - vertexposition[0][2]->Y());
1947 ////////////////////////////////////////////////////
1948 //Setting the parameters for Isometry Transformation
1949 ////////////////////////////////////////////////////
1950 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1951 + fgkCarbonFiberSupportTopEdgeDist[0]
1952 + fgkCarbonFiberSupportWidth);
1953 Double_t* param = new Double_t[4];
1954 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1955 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1956 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1957 (GetReflection(vertexposition[0][j],param))->Y());
1958 char* carbonfibersupportshapename[kshapesnumber] =
1959 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1960 char* carbonfibersupportname[kshapesnumber] =
1961 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1962 TGeoArb8* carbonfibersupportshape[kshapesnumber];
1963 TGeoVolume* carbonfibersupport[kshapesnumber];
1964 TList* carbonfibersupportlist = new TList();
1965 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1966 Double_t carbonfibersupportheight =
1967 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1968 *TMath::DegToRad());
1969 for(Int_t i = 0; i< kshapesnumber; i++){
1970 carbonfibersupportshape[i] =
1971 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1972 carbonfibersupportshapename[i],i==0 ? 1: -1);
1973 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1974 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1975 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1976 carbonfibersupportlist->Add(carbonfibersupport[i]);
1977 }
1978 /////////////////////////////////////////////////////////////
1979 // Deallocating memory
1980 /////////////////////////////////////////////////////////////
1981 for(Int_t i=0; i< kshapesnumber; i++){
1982 for(Int_t j=0; j< kvertexnumber; j++)
1983 delete vertexposition[i][j];
1984 delete [] vertexposition[i];
1985 }
1986 delete [] param;
44285dfa 1987 /////////////////////////////////////////////////////////////
bf210566 1988 return carbonfibersupportlist;
d7599219 1989}
1990/////////////////////////////////////////////////////////////////////////////////
bf210566 1991TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 1992 /////////////////////////////////////////////////////////////
bf210566 1993 // Method generating SSD Carbon Fiber Junction
44285dfa 1994 /////////////////////////////////////////////////////////////
bf210566 1995 const Int_t kvertexnumber = 6;
1996 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
1997 Double_t reflectionparam[3] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1998 * TMath::DegToRad()),-1.,0.};
1999 TVector3* vertex[kvertexnumber];
2000 vertex[0] = new TVector3();
2001 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2002 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2003 * TMath::DegToRad()),
2004 fgkCarbonFiberJunctionEdge[0]
2005 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
2006 * TMath::DegToRad()));
2007 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
2008 fgkCarbonFiberJunctionEdge[1]);
2009 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
2010 vertex[1] = GetReflection(vertex[5],reflectionparam);
2011 vertex[2] = GetReflection(vertex[4],reflectionparam);
2012 Double_t xvertexpoints[6], yvertexpoints[6];
2013 for(Int_t i=0; i<kvertexnumber; i++)
2014 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
2015 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2016 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
2017 carbonfiberjunctionshape->DefineSection(1,0.5*width);
2018 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
2019 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
2020 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
2021 /////////////////////////////////////////////////////////////
2022 // Deallocating memory
2023 /////////////////////////////////////////////////////////////
2024 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
2025 /////////////////////////////////////////////////////////////
2026 return carbonfiberjunction;
2027}
2028////////////////////////////////////////////////////////////////////////////////
2029TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
2030 /////////////////////////////////////////////////////////////
2031 // Method generating the Carbon Fiber Lower Support
2032 /////////////////////////////////////////////////////////////
2033 const Int_t kvertexnumber = 4;
2034 const Int_t kshapesnumber = 2;
2035 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
2036 fgkCarbonFiberLowerSupportWidth};
2037 TVector3** vertexposition[kshapesnumber];
2038 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2039 new TVector3*[kvertexnumber];
2040 //First Shape Vertex Positioning
2041 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2042 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2043 - fgkCarbonFiberLowerSupportLowerLenght);
2044 vertexposition[0][2] = new TVector3();
2045 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2046 //Second Shape Vertex Positioning
2047 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2048 - fgkCarbonFiberLowerSupportVolumePosition[0])
2049 / fgkCarbonFiberTriangleLength);
2050 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2051 vertexposition[0][0]->X()*TMath::Tan(theta)
2052 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2053 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2054 vertexposition[0][1]->X()*TMath::Tan(theta)
2055 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2056 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2057 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2058 fgkCarbonFiberLowerSupportVolumePosition[1]);
2059 char* carbonfiberlowersupportshapename[kshapesnumber] =
2060 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
2061 char* carbonfiberlowersupportname[kshapesnumber] =
2062 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2063 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2064 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2065 TList* carbonfiberlowersupportlist = new TList();
2066 for(Int_t i = 0; i< kshapesnumber; i++){
2067 carbonfiberlowersupportshape[i] =
2068 GetArbShape(vertexposition[i],width,
2069 fgkCarbonFiberLowerSupportHeight,
2070 carbonfiberlowersupportshapename[i]);
2071 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2072 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2073 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2074 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2075 }
2076 /////////////////////////////////////////////////////////////
2077 // Deallocating memory
2078 /////////////////////////////////////////////////////////////
2079 for(Int_t i=0; i< kshapesnumber; i++){
2080 for(Int_t j=0; j< kvertexnumber; j++)
2081 delete vertexposition[i][j];
2082 delete [] vertexposition[i];
2083 }
2084 /////////////////////////////////////////////////////////////
2085 return carbonfiberlowersupportlist;
2086}
2087///////////////////////////////////////////////////////////////////////////////
2088TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2089 Double_t width, Double_t* thickness)const{
2090 /////////////////////////////////////////////////////////////
2091 // Method generating the Sensor Support
2092 /////////////////////////////////////////////////////////////
2093 const Int_t kvertexnumber = 6;
2094 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2095 TVector3* vertexposition[kvertexnumber];
2096 vertexposition[0] = new TVector3();
2097 vertexposition[1] = new TVector3(0.0,length);
2098 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2099 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2100 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2101 vertexposition[5] = new TVector3(vertexposition[4]->X());
2102 Double_t xvertexpoints[6], yvertexpoints[6];
2103 for(Int_t i=0; i<kvertexnumber; i++)
2104 xvertexpoints[i] = vertexposition[i]->X(),
2105 yvertexpoints[i] = vertexposition[i]->Y();
2106 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2107 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2108 ssdsensorsupportshape->DefineSection(1,0.5*width);
2109 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2110 ssdsensorsupportshape,fSSDSensorSupportMedium);
2111 /////////////////////////////////////////////////////////////
2112 // Deallocating memory
2113 /////////////////////////////////////////////////////////////
2114 for (Int_t i=0; i<kvertexnumber; i++)
2115 delete vertexposition[i];
2116 /////////////////////////////////////////////////////////////
2117 return ssdsensorsupport;
2118}
2119////////////////////////////////////////////////////////////////////////////////
2120TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2121 /////////////////////////////////////////////////////////////
2122 // Method generating the Cooling Tube Support
2123 /////////////////////////////////////////////////////////////
2124 if(nedges%2!=0) nedges--;
2125 const Int_t kvertexnumber = nedges+5;
2126 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2127 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2128 Double_t angle = 90.+phi;
2129 Double_t psi = 90.-phi;
2130 ///////////////////////////////////////
2131 // Vertex Positioning for TGeoXTru
2132 ///////////////////////////////////////
2133 TVector3** vertexposition = new TVector3*[kvertexnumber];
2134 vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
2135 fgkCoolingTubeSupportRmin*SinD(angle));
2136 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2137 fgkCoolingTubeSupportRmax*SinD(angle));
2138 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2139 fgkCoolingTubeSupportRmax);
2140 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2141 fgkCoolingTubeSupportRmax);
2142 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2143 vertexposition[1]->Y());
2144 for(Int_t i=0; i<nedges; i++)
2145 vertexposition[i+5] =
2146 new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
2147 fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
2148 ///////////////////////////////////////////////////////////////////////
2149 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2150 ///////////////////////////////////////////////////////////////////////
2151 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2152 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2153 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2154 for(Int_t i=0; i<kvertexnumber; i++){
2155 xvertexpoints[i] = vertexposition[i]->X();
2156 yvertexpoints[i] = vertexposition[i]->Y();
2157 }
2158 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2159 yvertexpoints);
2160 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2161 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2162 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2163 coolingtubesupportarcshape,
2164 fSSDTubeHolderMedium);
2165 coolingtubesupportarc->SetLineColor(fColorG10);
2166 //////////////////////////////////////////////////////////////////////////
2167 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2168 //////////////////////////////////////////////////////////////////////////
2169 TGeoTubeSeg* coolingtubesupportsegshape =
2170 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2171 fgkCoolingTubeSupportRmax,
2172 0.5*fgkCoolingTubeSupportWidth,
2173 phi,360-phi);
2174 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2175 coolingtubesupportsegshape,
2176 fSSDTubeHolderMedium);
2177 coolingtubesupportseg->SetLineColor(fColorG10);
2178 //////////////////////////////////////////////////////////////////////////
2179 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2180 //////////////////////////////////////////////////////////////////////////
2181 Double_t* boxorigin = new Double_t[3];
2182 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2183 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2184 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2185 0.5*fgkCoolingTubeSupportHeight,
2186 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2187 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2188 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2189 coolingtubesupportbox->SetLineColor(fColorG10);
2190 //////////////////////////////////////////////////////////////////////////
2191 // Cooling Tube for Cooling Tube Support
2192 //////////////////////////////////////////////////////////////////////////
2193 TGeoXtru* coolingtubearcshape[2];
2194 coolingtubearcshape[0] = new TGeoXtru(2);
2195 Double_t* xvert = new Double_t[nedges+2];
2196 Double_t* yvert = new Double_t[nedges+2];
2197 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2198 ////////////////////////////////////////
2199 // Positioning the vertices for TGeoXTru
2200 ////////////////////////////////////////
2201 xvert[0] = 0., yvert[0] = 0.;
2202 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2203 for(Int_t i=0; i< nedges; i++)
2204 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2205 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2206 ////////////////////////////////////////
2207 // Defining TGeoXTru PolyGone
2208 ////////////////////////////////////////
2209 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2210 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2211 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2212 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2213 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2214 TGeoVolume* coolingtubearc[2];
2215 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2216 coolingtubearcshape[0],fSSDCoolingTubeWater);
2217 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2218 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2219 coolingtubearc[0]->SetLineColor(fColorWater);
2220 coolingtubearc[1]->SetLineColor(fColorPhynox);
2221 ////////////////////////////////////////////
2222 // Defining TGeoTubeSeg Part of Cooling Tube
2223 ////////////////////////////////////////////
2224 TGeoTubeSeg* coolingtubesegshape[2];
2225 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2226 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2227 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2228 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2229 TGeoVolume* coolingtubeseg[2];
2230 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2231 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2232 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2233 coolingtubesegshape[1],fSSDCoolingTubeWater);
2234 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2235 coolingtubeseg[1]->SetLineColor(fColorWater);
2236 /////////////////////////////////////////////////////////////
2237 // Virtual Volume containing Cooling Tube Support
2238 /////////////////////////////////////////////////////////////
2239 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2240 const Int_t kvirtualvertexnumber = 8;
2241 TVector3* virtualvertex[kvirtualvertexnumber];
2242 ////////////////////////////////////////
2243 // Positioning the vertices for TGeoXTru
2244 ////////////////////////////////////////
2245 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2246 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2247 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2248 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2249 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2250 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2251 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2252 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2253 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2254 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2255 xmothervertex[i] = virtualvertex[i]->X(),
2256 ymothervertex[i] = virtualvertex[i]->Y();
2257 ////////////////////////////////////////
2258 // Defining TGeoXTru PolyGone
2259 ////////////////////////////////////////
2260 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2261 ymothervertex);
2262 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2263 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2264 TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2265 virtualCoolingTubeSupportShape,fSSDAir);
2266 ////////////////////////////////////////
2267 // Positioning Volumes in Virtual Volume
2268 ////////////////////////////////////////
2269 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2270 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2271 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2272 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2273 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2274 virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2275 virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2276 virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2277 virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2278 /////////////////////////////////////////////////////////////
2279 // Deallocating memory
2280 /////////////////////////////////////////////////////////////
2281 delete [] vertexposition;
2282 delete xvertexpoints;
2283 delete yvertexpoints;
2284 delete xvert;
2285 delete yvert;
2286 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2287 delete virtualvertex[i];
2288 /////////////////////////////////////////////////////////////
2289 return virtualcoolingtubesupport;
2290}
2291/////////////////////////////////////////////////////////////////////////////////
2292TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2293 /////////////////////////////////////////////////////////////
2294 // Method generating List containing SSD Hybrid Components
2295 /////////////////////////////////////////////////////////////
2296 TList* ssdhybridlist = new TList();
2297 const Int_t kssdstiffenernumber = 2;
2298 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2299 - 2.*fgkSSDModuleStiffenerPosition[1]
2300 - fgkSSDStiffenerWidth;
2301 Double_t ssdchipcablesradius[kssdstiffenernumber];
2302 for(Int_t i=0; i<kssdstiffenernumber; i++)
2303 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2304 - fgkSSDChipCablesHeight[0]
2305 - fgkSSDChipCablesHeight[1]);
2306 /////////////////////////////////////////////////////////////
2307 // Mother Volumes Containers
2308 /////////////////////////////////////////////////////////////
2309 const Int_t kmothernumber = 2;
2310 const Int_t kmothervertexnumber = 12;
2311 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2312 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2313 ///////////////////////
2314 // Setting the vertices
2315 ///////////////////////
2316 xmothervertex[0][0] = -0.5*fgkSSDStiffenerLength;
2317 xmothervertex[0][1] = xmothervertex[0][0];
2318 xmothervertex[0][2] = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
2319 xmothervertex[0][3] = xmothervertex[0][2];
2320 xmothervertex[0][4] = xmothervertex[0][0];
2321 xmothervertex[0][5] = xmothervertex[0][4];
2322 xmothervertex[0][6] = -xmothervertex[0][0];
2323 xmothervertex[0][7] = xmothervertex[0][6];
2324 xmothervertex[0][8] = -xmothervertex[0][2];
2325 xmothervertex[0][9] = xmothervertex[0][8];
2326 xmothervertex[0][10] = xmothervertex[0][7];
2327 xmothervertex[0][11] = xmothervertex[0][10];
2328 for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
2329 for(Int_t i = 0; i<kmothernumber; i++){
2330 ymothervertex[i][0] = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
2331 + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
2332 ymothervertex[i][1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
2333 ymothervertex[i][2] = ymothervertex[i][1];
2334 ymothervertex[i][3] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
2335 ymothervertex[i][4] = ymothervertex[i][3];
2336 ymothervertex[i][5] = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
2337 ymothervertex[i][6] = ymothervertex[i][5];
2338 ymothervertex[i][7] = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
2339 ymothervertex[i][8] = ymothervertex[i][7];
2340 ymothervertex[i][9] = 0.5*fgkSSDStiffenerWidth;
2341 ymothervertex[i][10] = ymothervertex[i][9];
2342 ymothervertex[i][11] = ymothervertex[i][0];
2343 }
2344 TGeoXtru* ssdhybridmothershape[kmothernumber];
2345 TGeoVolume* ssdhybridmother[kmothernumber];
2346 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2347 for(Int_t i=0; i<kmothernumber; i++){
2348 ssdhybridmothershape[i] = new TGeoXtru(2);
2349 ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
2350 ymothervertex[i]);
2351 ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2352 -fgkSSDChipCablesHeight[i+2]);
2353 ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
2354 ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
2355 fSSDAir);
2356 }
2357 /////////////////////////////////////////////////////////////
2358 // SSD Stiffener
2359 /////////////////////////////////////////////////////////////
2360 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2361 0.5*fgkSSDStiffenerLength,
2362 0.5*fgkSSDStiffenerWidth,
2363 0.5*fgkSSDStiffenerHeight);
2364 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2365 fSSDStiffenerMedium);
2366 ssdstiffener->SetLineColor(fColorStiffener);
2367 TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
2368 for(Int_t i=0; i<kssdstiffenernumber; i++)
2369 ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
2370 /////////////////////////////////////////////////////////////
2371 // SSD Chip System
2372 /////////////////////////////////////////////////////////////
2373 TList* ssdchipsystemlist = GetSSDChipSystem();
2374 Double_t ssdchipseparation = fgkSSDSensorLength
2375 - 2.*fgkSSDModuleStiffenerPosition[1]
2376 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
2377 - 0.5*fgkSSDChipWidth);
2378 Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
2379 + fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
2380 TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
2381 - 0.5*ssdchipsystemlength,
2382 0.5*(ssdstiffenerseparation-ssdchipseparation),
2383 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
2384////////////////////////////
2385// Capacitor 0603-2200 nF
2386///////////////////////////
2387 const Int_t knapacitor0603number = 5;
2388 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
2389 0.5*fgkSSDCapacitor0603Length,
2390 0.5*fgkSSDCapacitor0603Width,
2391 0.5*fgkSSDCapacitor0603Height);
2392 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2393 fSSDStiffener0603CapacitorMedium);
2394 capacitor0603->SetLineColor(fColorAl);
bf210566 2395 for(Int_t i=0; i<kmothernumber; i++){
2396 for(Int_t j=0; j<kssdstiffenernumber; j++){
2397 ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
2398 for(Int_t k=1; k<knapacitor0603number+1; k++){
2399 ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
2400 new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
2401 j*ssdstiffenerseparation
2402 + 0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
2403 + (j==0? -1:+1)*fgkSSDCapacitor0603Width),
2404 - 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
2405 }
2406 }
2407 ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
2408 ssdhybridlist->Add(ssdhybridmother[i]);
2409 }
2410/////////////////////////////////////////////////////////////
2411// Mother Volume Containing Capacitor Part
2412/////////////////////////////////////////////////////////////
2413 const Int_t kcapacitormothernumber = 8;
2414 Double_t xcapacitorvertex[kcapacitormothernumber];
2415 Double_t ycapacitorvertex[kcapacitormothernumber];
2416 ///////////////////////
2417 // Setting the vertices
2418 ///////////////////////
2419 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2420 xcapacitorvertex[1] = xcapacitorvertex[0];
2421 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2422 xcapacitorvertex[3] = xcapacitorvertex[2];
2423 xcapacitorvertex[4] = xcapacitorvertex[0];
2424 xcapacitorvertex[5] = xcapacitorvertex[0];
2425 xcapacitorvertex[6] = -xcapacitorvertex[0];
2426 xcapacitorvertex[7] = xcapacitorvertex[6];
2427 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2428 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2429 ycapacitorvertex[2] = ycapacitorvertex[1];
2430 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2431 ycapacitorvertex[4] = ycapacitorvertex[3];
2432 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2433 ycapacitorvertex[6] = ycapacitorvertex[5];
2434 ycapacitorvertex[7] = ycapacitorvertex[0];
2435 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2436 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2437 ycapacitorvertex);
2438 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2439 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2440 TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2441 fSSDAir);
d7599219 2442////////////////////////////
bf210566 2443// Connector
d7599219 2444///////////////////////////
bf210566 2445 const Int_t kssdconnectornumber = 2;
2446 TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2447 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2448 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2449 + fgkSSDConnectorAlHeight};
2450 const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2451 TGeoVolume* ssdconnector[kssdconnectornumber];
2452 for(Int_t i=0; i<kssdconnectornumber; i++){
2453 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2454 0.5*fgkSSDConnectorWidth,
2455 0.5*((1-i)*fgkSSDConnectorAlHeight
2456 + i*fgkSSDConnectorNiHeight),
2457 i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2458 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2459 i==0 ? fSSDAlTraceFlexMedium
2460 : fSSDStiffenerConnectorMedium);
2461 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2462 }
2463 TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2464 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2465 + fgkSSDConnectorPosition[0]
2466 - fgkSSDConnectorSeparation
2467 - 1.5*fgkSSDConnectorLength,
2468 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2469 - fgkSSDConnectorPosition[1]
2470 - ssdconnectorshape[0]->GetDY(),0.0);
2471 ssdconnectortrans[1] = new TGeoTranslation(
2472 - ssdstiffenershape->GetDX()
2473 + fgkSSDConnectorPosition[0]
2474 - 0.5*fgkSSDConnectorLength,
2475 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2476 - fgkSSDConnectorPosition[1]
2477 - ssdconnectorshape[0]->GetDY(),0.0);
2478 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2479 - fgkSSDConnectorPosition[0]
2480 + fgkSSDConnectorSeparation
2481 + 1.5*fgkSSDConnectorLength,
2482 -(ssdstiffenershape->GetDY()
2483 - fgkSSDConnectorPosition[1]
2484 - ssdconnectorshape[0]->GetDY()),0.0);
2485 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2486 - fgkSSDConnectorPosition[0]
2487 + 0.5*fgkSSDConnectorLength,
2488 -(ssdstiffenershape->GetDY()
2489 - fgkSSDConnectorPosition[1]
2490 - ssdconnectorshape[0]->GetDY()),0.0);
2491 for(Int_t i=0; i<2*kssdconnectornumber; i++)
2492 for(Int_t j=0; j<kssdconnectornumber; j++)
2493 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2494////////////////////////////
2495// Capacitor 1812-330 nF
2496///////////////////////////
2497 Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2498 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2499 0.5*fgkSSDCapacitor1812Length,
2500 0.5*fgkSSDCapacitor1812Width,
bf210566 2501 0.5*fgkSSDCapacitor1812Height,
2502 ssdcapacitor1812origin);
44285dfa 2503 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2504 fSSDStiffener1812CapacitorMedium);
2505 capacitor1812->SetLineColor(fColorAl);
bf210566 2506 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2507 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2508 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2509 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
d7599219 2510////////////////////////////
2511//Hybrid Wire
2512////////////////////////////
44285dfa 2513 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2514 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2515 - fgkSSDConnectorSeparation;
44285dfa 2516 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2517 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
44285dfa 2518 Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
2519 + TMath::Power(wirey,2));
2520 Double_t wireangle = TMath::ATan(wirex/wirey);
2521 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2522 fgkSSDWireRadius, 0.5*ssdwireradius);
2523 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2524 fSSDStiffenerHybridWireMedium);
2525 hybridwire->SetLineColor(fColorPhynox);
2526 TGeoCombiTrans* hybridwirecombitrans[2];
2527 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2528 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2529 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2530 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2531 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2532 ssdstiffenershape->GetDZ()
2533 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
d7599219 2534 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2535 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2536 0.0,
2537 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2538 0.0,
2539 new TGeoRotation("HybridWireRot2",
2540 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2541 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2542 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2543 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2544 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2545 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2546 /////////////////////////////////////////////////////////////
bf210566 2547 // Deallocating memory
44285dfa 2548 /////////////////////////////////////////////////////////////
bf210566 2549 delete hybridwirecombitrans[0];
2550 delete hybridwirecombitrans[1];
2551 delete ssdchipsystemlist;
2552 return ssdhybridlist;
2553 /////////////////////////////////////////////////////////////
2554}
2555///////////////////////////////////////////////////////////////////////////////
2556TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2557 /////////////////////////////////////////////////////////////
2558 // SSD Cooling Block System
2559 /////////////////////////////////////////////////////////////
2560 // SSD Cooling Block and Cooling Tube Transformations
2561 /////////////////////////////////////////////////////////////
2562 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2563 localcoolingblockrot->SetAngles(0.,90.,0.);
2564 TGeoCombiTrans* localcoolingblockmatrix =
2565 new TGeoCombiTrans(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
2566 TGeoTranslation* localcoolingblocktrans;
2567 TVector3* coolingblocktransvector;
2568 coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2569 + fgkSSDCoolingBlockLength,
2570 fgkSSDSensorLength
2571 - 2.*fgkSSDModuleStiffenerPosition[1]
2572 - fgkSSDCoolingBlockWidth);
2573 const Int_t kcoolingblocktransnumber = 2;
2574 const Int_t kcoolingblocknumber = 4;
2575 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2576 TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2577 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2578 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2579 TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2580 localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
2581 0.5*fgkSSDCoolingBlockWidth,
2582 fgkSSDCoolingBlockHoleCenter);
2583 TGeoCombiTrans* localcoolingtubematrix = new TGeoCombiTrans(*localcoolingtubetrans,
2584 *localcoolingtuberot);
2585 Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2586 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
2587 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2588 localcoolingblocktrans=
2589 new TGeoTranslation(i*coolingblocktransvector->X()+2*coolingtubedistance,
2590 j*coolingblocktransvector->Y(),
2591 - 0.5*(fgkSSDCoolingBlockHoleCenter
2592 + fgkCoolingTubeRmax));
2593 coolingblockmatrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
2594 *(*localcoolingblockmatrix));
2595 coolingtubematrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
2596 *(*localcoolingtubematrix));
2597 }
d7599219 2598 }
bf210566 2599 /////////////////////////////////////////////////////////////
2600 // Virtual Volume containing CoolingBlock System
2601 /////////////////////////////////////////////////////////////
2602 TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2603 const Int_t kmothervertexnumber = 16;
2604 Double_t xmothervertex[kmothervertexnumber];
2605 Double_t ymothervertex[kmothervertexnumber];
2606 ///////////////////////
2607 // Setting the vertices
2608 ///////////////////////fgkCoolingTubeSupportRmax
2609 xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2610 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2611 + fgkSSDCoolingBlockWidth;
2612 xmothervertex[2] = coolingblocktransvector->X()
2613 + fgkSSDCoolingBlockLength
2614 + 4*coolingtubedistance;
2615 ymothervertex[2] = ymothervertex[1];
2616 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2617 xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2618 ymothervertex[4] = ymothervertex[0];
2619 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2620 xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2621 ymothervertex[6] = ymothervertex[5];
2622 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2623 - fgkSSDCoolingBlockWidth;
2624 xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2625 xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2626 - coolingtubedistance;
2627 xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2628 ymothervertex[10] = ymothervertex[9];
2629 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2630 xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2631 xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2632 xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2633 ymothervertex[14] = ymothervertex[13];
2634 xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2635 //////////////////////////////////////////////////////////
2636 coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2637 xmothervertex,ymothervertex);
2638 coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2639 + fgkCoolingTubeRmax));
2640 coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2641 + fgkCoolingTubeRmax));
2642 TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
2643 coolingsystemothershape,fSSDAir);
2644 /////////////////////////////////////////////////////////////
2645 // SSD Cooling Tube Part
2646 /////////////////////////////////////////////////////////////
2647 TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
2648 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2649 0.5*fgkSSDCoolingBlockWidth);
2650 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
2651 0.5*fgkSSDCoolingBlockWidth);
2652 TGeoVolume* coolingtube[fgkcoolingtubenumber];
2653 coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
2654 fSSDCoolingTubePhynox);
2655 coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
2656 fSSDCoolingTubeWater);
2657 coolingtube[0]->SetLineColor(fColorPhynox);
2658 coolingtube[1]->SetLineColor(fColorWater);
2659 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2660 /////////////////////////////////////////////////////////////
2661 // Adding Cooling block to mother volume
2662 /////////////////////////////////////////////////////////////
2663 for(Int_t i=0; i<kcoolingblocknumber; i++){
2664 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2665 coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
2666 coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
d7599219 2667 }
bf210566 2668 /////////////////////////////////////////////////////////////
2669 // Deallocating memory
2670 /////////////////////////////////////////////////////////////
2671 delete coolingblocktransvector;
2672 delete localcoolingblocktrans;
2673 delete localcoolingblockrot;
2674 delete localcoolingblockmatrix;
2675 delete localcoolingtubetrans;
2676 delete localcoolingtuberot;
2677 /////////////////////////////////////////////////////////////
2678 // Checking overlaps
2679 /////////////////////////////////////////////////////////////
6727e2db 2680 //coolingsystemother->CheckOverlaps(0.01);
bf210566 2681 /////////////////////////////////////////////////////////////
2682 return coolingsystemother;
d7599219 2683}
2684/////////////////////////////////////////////////////////////////////////////////
bf210566 2685TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2686 /////////////////////////////////////////////////////////////
bf210566 2687 // SSD Flex
44285dfa 2688 /////////////////////////////////////////////////////////////
bf210566 2689 const Int_t kssdflexlayernumber = 2;
2690 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2691 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2692 const Int_t kmothervertexnumber = 17;
2693 Double_t xmothervertex[kmothervertexnumber];
2694 Double_t ymothervertex[kmothervertexnumber];
2695 /////////////////////////////////////////////
2696 // Auxiliary variables for vertex positioning
2697 /////////////////////////////////////////////
2698 const Int_t kssdflexboxnumber = 5;
44285dfa 2699 Double_t ssdflexboxlength[kssdflexboxnumber];
2700 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2701 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2702 * fgkSSDChipSeparationLength
2703 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2704 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2705 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2706 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2707 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2708 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2709 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2710 - ssdflexboxlength[1];
44285dfa 2711 Double_t ssdflexboxwidth[kssdflexboxnumber];
2712 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2713 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2714 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2715 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2716 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2717 ///////////////////////
2718 // Setting the vertices
2719 ///////////////////////
2720 xmothervertex[0] = 0.0;
2721 xmothervertex[1] = xmothervertex[0];
2722 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2723 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2724 + ssdflexboxlength[4];
2725 xmothervertex[4] = xmothervertex[3];
2726 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2727 xmothervertex[6] = xmothervertex[5];
2728 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2729 xmothervertex[8] = xmothervertex[7];
2730 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2731 xmothervertex[10] = xmothervertex[9];
2732 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2733 xmothervertex[12] = xmothervertex[11];
2734 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2735 xmothervertex[14] = xmothervertex[13];
2736 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2737 xmothervertex[16] = xmothervertex[15];
2738 ymothervertex[0] = 0.0;
2739 ymothervertex[1] = fgkSSDFlexWidth[1];
2740 ymothervertex[2] = fgkSSDFlexWidth[0];
2741 ymothervertex[3] = ymothervertex[2];
2742 ymothervertex[4] = ymothervertex[0];
2743 ymothervertex[5] = ymothervertex[4];
2744 ymothervertex[6] = ssdflexboxwidth[2];
2745 ymothervertex[7] = ymothervertex[6];
2746 ymothervertex[8] = ymothervertex[0];
2747 ymothervertex[9] = ymothervertex[8];
2748 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2749 ymothervertex[11] = ymothervertex[10];
2750 ymothervertex[12] = ymothervertex[0];
2751 ymothervertex[13] = ymothervertex[12];
2752 ymothervertex[14] = ymothervertex[7];
2753 ymothervertex[15] = ymothervertex[14];
2754 ymothervertex[16] = ymothervertex[0];
2755 /////////////////////////////////////////////////////////////
2756 // First Mother Volume containing SSDFlex
2757 /////////////////////////////////////////////////////////////
2758 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2759 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2760 ymothervertex);
2761 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2762 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2763 TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2764 fSSDAir);
2765 /////////////////////////////////////////////////////////////
2766 // SSDFlex Layer Shapes
2767 /////////////////////////////////////////////////////////////
2768 for(Int_t i=0; i<kssdflexlayernumber; i++){
2769 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2770 ymothervertex);
2771 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2772 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2773 }
2774 /////////////////////////////////////
2775 // Setting Layers into Mother Volume
2776 /////////////////////////////////////
2777 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2778 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2779 fSSDKaptonFlexMedium};
2780 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2781 "AlFlexLay2","KaptonFlexLay2"};
2782 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2783 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2784 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2785 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2786 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2787 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2788 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2789 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2790 + fgkSSDFlexHeight[1]));
2791 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2792 }
6727e2db 2793 //ssdflexmother->CheckOverlaps(0.01);
bf210566 2794 return ssdflexmother;
d7599219 2795}
2796/////////////////////////////////////////////////////////////////////////////////
bf210566 2797TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2798 /////////////////////////////////////////////////////////////
2799 // Method generating SSD End Flex
d7599219 2800 /////////////////////////////////////////
bf210566 2801 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2802 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2803 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2804 * TMath::DegToRad()*ssdflexradiusmax
2805 - fgkSSDFlexLength[2]-TMath::Pi()
2806 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
2807 const Int_t knedges = 20;
2808 const Int_t karcnumber = 2;
2809 TVector3* vertexposition[karcnumber*(knedges+1)];
2810 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2811 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2812 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2813 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2814 - 90.0*TMath::DegToRad()};
2815 TVector3* referencetrans[karcnumber];
2816 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2817 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2818 radius[0]);
2819 referencetrans[1] = new TVector3(referencetrans[0]->X()
2820 + fgkSSDFlexLength[2],
2821 - fgkSSDStiffenerHeight);
2822for(Int_t i=0; i<karcnumber; i++){
2823 for(Int_t j=0; j<knedges+1; j++){
2824 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2825 radius[i]*SinD(angle[i]));
2826 angle[i] += deltangle[i]*(1.0-2.0*i);
2827 }
2828 }
2829 ///////////////////////
2830 // Setting the vertices
2831 ///////////////////////
2832 const Int_t kendflexlayernumber = 4;
2833 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2834 TVector3** vertex[kendflexlayernumber];
2835 for(Int_t i=0; i<kendflexlayernumber; i++)
2836 vertex[i] = new TVector3*[kendflexvertexnumber];
2837 TVector3* transvector[kendflexlayernumber+1];
2838 TVector3* deltatransvector = new TVector3();
2839 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2840 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2841 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2842 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2843 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2844 * CosD(fgkSSDFlexAngle),
2845 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2846 * SinD(fgkSSDFlexAngle),0.0);
2847 *transvector[i] = *transvector[i-1]+*deltatransvector;
2848 }
2849 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2850 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2851 for(Int_t i=0; i<karcnumber; i++){
2852 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2853 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2854 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2855 /radius[i];
2856 }
2857 }
2858 for(Int_t i=0; i<kendflexlayernumber; i++){
2859 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2860 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2861 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2862 if(j<(knedges+1)){
2863 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2864 vertexposition[j]->Y()*ratioradius[0][i+1]);
2865 vertex[i][j+2]->RotateZ(referenceangle[0]);
2866 *vertex[i][j+2] += *referencetrans[0];
2867 vertex[i][4*(knedges+1)-j+1] =
2868 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2869 vertexposition[j]->Y()*ratioradius[0][i]);
2870 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2871 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2872 }
2873 else{
2874
2875 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2876 vertexposition[j]->Y()*ratioradius[1][i+1]);
2877 vertex[i][j+2]->RotateZ(referenceangle[1]);
2878 *vertex[i][j+2] += *referencetrans[1];
2879 vertex[i][4*(knedges+1)-j+1] =
2880 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2881 vertexposition[j]->Y()*ratioradius[1][i]);
2882 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2883 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2884 }
2885 }
2886 }
44285dfa 2887 /////////////////////////////////////////////////////////////
bf210566 2888 // First Mother Volume containing SSDEndFlex
2889 /////////////////////////////////////////////////////////////
2890 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2891 Double_t xmothervertex[kendflexvertexnumber];
2892 Double_t ymothervertex[kendflexvertexnumber];
2893 xmothervertex[0] = vertex[0][0]->X();
2894 ymothervertex[0] = vertex[0][0]->Y();
2895 for(Int_t i=1; i<kendflexvertexnumber; i++){
2896 if(i<2*(knedges+1)+2){
2897 xmothervertex[i] = vertex[3][i]->X();
2898 ymothervertex[i] = vertex[3][i]->Y();
2899 }
2900 else{
2901 xmothervertex[i] = vertex[0][i]->X();
2902 ymothervertex[i] = vertex[0][i]->Y();
2903 }
2904 }
2905 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2906 xmothervertex,ymothervertex);
2907 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2908 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2909 TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2910 ssdendflexmothershape,fSSDAir);
2911 //////////////////////////////////////
2912 // End Flex TGeoXtru Layer Definition
2913 //////////////////////////////////////
2914 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2915 TGeoVolume* ssdendflex[kendflexlayernumber];
2916 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2917 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2918 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2919 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2920 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2921 fSSDKaptonFlexMedium};
2922 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2923 "AlEndFlexLay2","KaptonEndFlexLay2"};
2924 for(Int_t i=0; i<kendflexlayernumber; i++){
2925 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2926 xvertex[i][j] = vertex[i][j]->X();
2927 yvertex[i][j] = vertex[i][j]->Y();
2928 }
2929 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2930 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2931 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2932 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2933 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2934 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2935 ssdendflexmother->AddNode(ssdendflex[i],1);
2936 }
44285dfa 2937 /////////////////////////////////////////////////////////////
bf210566 2938 // Deallocating memory
44285dfa 2939 /////////////////////////////////////////////////////////////
bf210566 2940 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2941 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2942 for(Int_t i=0; i<kendflexlayernumber; i++){
2943 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2944 delete [] vertex[i];
2945 }
2946 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2947 delete deltatransvector;
44285dfa 2948 /////////////////////////////////////////////////////////////
6727e2db 2949 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 2950 return ssdendflexmother;
d7599219 2951}
9b0c60ab 2952///////////////////////////////////////////////////////////////////////////////
bf210566 2953TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 2954 /////////////////////////////////////////////////////////////
9b0c60ab 2955 // Method generating the Mounting Block
bf210566 2956 /////////////////////////////////////////////////////////////
9b0c60ab 2957 const Int_t kvertexnumber = 8;
2958 Double_t xvertex[kvertexnumber];
2959 Double_t yvertex[kvertexnumber];
2960 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2961 xvertex[1] = xvertex[0];
2962 xvertex[2] = -xvertex[0];
2963 xvertex[3] = xvertex[2];
2964 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2965 - fgkSSDMountingBlockLength[2]);
2966 xvertex[5] = xvertex[4];
2967 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2968 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2969 - fgkSSDMountingBlockScrewHoleRadius[0];
2970 xvertex[7] = xvertex[6];
2971 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
2972 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
2973 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2974 yvertex[2] = yvertex[1];
2975 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2976 yvertex[4] = yvertex[3];
2977 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2978 - fgkSSDMountingBlockHeight[0];
2979 yvertex[6] = yvertex[5];
2980 yvertex[7] = yvertex[0];
2981 ///////////////////////////////////////////////////////////////////////
2982 // TGeoXTru Volume definition for Mounting Block Part
2983 ///////////////////////////////////////////////////////////////////////
2984 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2985 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2986 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2987 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 2988 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 2989 ssdmountingblockshape,
2990 fSSDMountingBlockMedium);
2991 ssdmountingblock->SetLineColor(fColorG10);
2992 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2993 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2994 TGeoRotation* mountingblockrot = new TGeoRotation();
2995 mountingblockrot->SetAngles(90.,180.,-90.);
2996 mountingblockcombitrans->SetRotation(*mountingblockrot);
2997 /////////////////////////////////////////////////////////////
2998 // Generating the Mounting Block Screw Vertices
2999 /////////////////////////////////////////////////////////////
3000 const Int_t kscrewvertexnumber = 15;
3001 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
3002 - fgkSSDMountingBlockScrewHoleEdge)
3003 / fgkSSDMountingBlockScrewHoleRadius[0])
3004 * TMath::RadToDeg();
3005 Double_t phi0 = 90.+alpha;
3006 Double_t phi = 270.-2*alpha;
3007 Double_t deltaphi = phi/kscrewvertexnumber;
3008 TVector3* screwvertex[kscrewvertexnumber+1];
3009 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
3010 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
3011 *CosD(phi0+i*deltaphi),
3012 fgkSSDMountingBlockScrewHoleRadius[0]
3013 *SinD(phi0+i*deltaphi));
3014 Double_t xscrewvertex[kscrewvertexnumber+6];
3015 Double_t yscrewvertex[kscrewvertexnumber+6];
3016 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
3017 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
3018 - fgkSSDMountingBlockScrewHoleEdge);
3019 xscrewvertex[1] = xscrewvertex[0];
3020 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3021 xscrewvertex[2] = screwvertex[0]->X();
3022 yscrewvertex[2] = yscrewvertex[1];
3023 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
3024 xscrewvertex[i+3] = screwvertex[i]->X();
3025 yscrewvertex[i+3] = screwvertex[i]->Y();
3026 }
3027 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3028 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
3029 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
3030 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
3031 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
3032 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
3033 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
3034 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
3035 + fgkSSDMountingBlockHeight[2]);
3036 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
3037 ssdmountingblockscrewshape,
3038 fSSDMountingBlockMedium);
3039 ssdmountingblockscrew->SetLineColor(fColorG10);
3040 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
3041 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
3042 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3043 - yscrewvertex[1],
3044 0.5*fgkSSDMountingBlockHeight[0]
3045 - fgkSSDMountingBlockHeight[2]
3046 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3047 + fgkSSDMountingBlockHeight[2]
3048 - yvertex[0]));
3049 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3050 -0.5*fgkSSDMountingBlockScrewHoleEdge,
3051 yscrewvertex[1]
3052 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3053 +fgkSSDMountingBlockHeight[2]
3054 -yvertex[0]));
3055 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3056 yscrewvertex[1],
3057 - 0.5*fgkSSDMountingBlockHeight[0]
3058 + fgkSSDMountingBlockHeight[2]
3059 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3060 + fgkSSDMountingBlockHeight[2]
3061 - yvertex[0]));
3062 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3063 yscrewvertex[1],
3064 - yscrewvertex[1]
3065 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3066 + fgkSSDMountingBlockHeight[2]
3067 - yvertex[0]));
3068 TGeoRotation* ssdmountingblockscrewrot[4];
3069 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3070 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3071 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3072 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3073 for(Int_t i=1; i<4; i++)
3074 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3075 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3076 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3077 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3078 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3079 + xvertex[0],yscrewvertex[1]
3080 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3081 + fgkSSDMountingBlockHeight[2]
3082 - yvertex[0]),0.);
3083 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3084 for(Int_t i=0; i<4; i++){
3085 ssdmountingblockscrewmatrix[i] =
3086 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3087 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3088 }
3089 ///////////////////////////////////////////////////////////////////////
3090 // TGeoXtru for Mother Volume
3091 ///////////////////////////////////////////////////////////////////////
3092 const Int_t kvertexmothernumber = 12;
3093 Double_t xmothervertex[kvertexmothernumber];
3094 Double_t ymothervertex[kvertexmothernumber];
3095 for(Int_t i=0; i<6; i++){
3096 xmothervertex[i] = xvertex[i];
3097 ymothervertex[i] = yvertex[i];
3098 }
3099 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3100 ymothervertex[6] = ymothervertex[5];
3101 xmothervertex[7] = xmothervertex[6];
3102 ymothervertex[7] = ymothervertex[4];
3103 xmothervertex[8] = xmothervertex[7]
3104 + 0.5*(fgkSSDMountingBlockLength[1]
3105 - fgkSSDMountingBlockLength[2]);
3106 ymothervertex[8] = ymothervertex[4];
3107 xmothervertex[9] = xmothervertex[8];
3108 ymothervertex[9] = ymothervertex[2];
3109 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3110 ymothervertex[10] = ymothervertex[1];
3111 xmothervertex[11] = xmothervertex[10];
3112 ymothervertex[11] = ymothervertex[0];
3113 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3114 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3115 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3116 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3117 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3118 ssdmountingblockmothershape,
3119 fSSDAir);
3120 /////////////////////////////////////////////////////////////
3121 // Placing the Volumes into Mother Volume
3122 /////////////////////////////////////////////////////////////
3123 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3124 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3125 for(Int_t i=0; i<4; i++)
3126 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3127 ssdmountingblockscrewmatrix[i]);
3128 /////////////////////////////////////////////////////////////
3129 // Deallocating memory
3130 /////////////////////////////////////////////////////////////
3131 delete mountingblockrot;
3132 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3133 delete ssdmountingblockglobalrot;
3134 delete ssdmountingblockglobaltrans;
3135 /////////////////////////////////////////////////////////////
3136 return ssdmountingblockmother;
3137}
3138///////////////////////////////////////////////////////////////////////////////
3139 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3140 /////////////////////////////////////////////////////////////
3141 // Method generating the Mounting Block Clip
3142 /////////////////////////////////////////////////////////////
3143 const Int_t kmothervertexnumber = 10;
3144 Double_t xmothervertex[kmothervertexnumber];
3145 Double_t ymothervertex[kmothervertexnumber];
3146 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3147 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3148 xmothervertex[1] = xmothervertex[0];
3149 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3150 - fgkMountingBlockClibScrewRadius);
3151 xmothervertex[3] = xmothervertex[2];
3152 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3153 xmothervertex[5] = xmothervertex[4];
3154 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3155 xmothervertex[7] = xmothervertex[6];
3156 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3157 xmothervertex[9] = xmothervertex[8];
3158 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
3159 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
3160 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3161 ymothervertex[2] = ymothervertex[1];
3162 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3163 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3164 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3165 ymothervertex[4] = ymothervertex[3];
3166 ymothervertex[5] = ymothervertex[2];
3167 ymothervertex[6] = ymothervertex[5];
3168 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3169 ymothervertex[8] = ymothervertex[7];
3170 ymothervertex[9] = ymothervertex[0];
3171 ///////////////////////////////////////////////////////////////////////
3172 // TGeoXTru Volume definition for Mounting Block Clip Part
3173 ///////////////////////////////////////////////////////////////////////
3174 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3175 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3176 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3177 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3178 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3179 ssdmountingblockclipshape,fSSDAir);
3180 ssdmountingblockclip->SetLineColor(4);
3181 ///////////////////////////////////////////////////////////////////////
3182 // TGeoXTru Volume definition for Clip
3183 ///////////////////////////////////////////////////////////////////////
3184 const Int_t kclipvertexnumber = 6;
3185 Double_t xclipvertex[kclipvertexnumber];
3186 Double_t yclipvertex[kclipvertexnumber];
3187 xclipvertex[0] = xmothervertex[0];
3188 xclipvertex[1] = xclipvertex[0];
3189 xclipvertex[2] = xmothervertex[6];
3190 xclipvertex[3] = xclipvertex[2];
3191 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3192 xclipvertex[5] = xclipvertex[4];
3193 yclipvertex[0] = ymothervertex[0];
3194 yclipvertex[1] = ymothervertex[1];
3195 yclipvertex[2] = yclipvertex[1];
3196 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3197 yclipvertex[4] = yclipvertex[3];
3198 yclipvertex[5] = yclipvertex[0];
3199 TGeoXtru* clipshape = new TGeoXtru(2);
3200 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3201 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3202 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3203 + fgkMountingBlockClibWidth);
3204 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3205 clip->SetLineColor(18);
3206 ///////////////////////////////////////////////////////////////////////
3207 // Ladder Support Piece
3208 ///////////////////////////////////////////////////////////////////////
3209 const Int_t ksupportvertexnumber = 4;
3210 Double_t xsupportvertex[ksupportvertexnumber];
3211 Double_t ysupportvertex[ksupportvertexnumber];
3212 xsupportvertex[0] = xclipvertex[5];
3213 xsupportvertex[1] = xsupportvertex[0];
3214 xsupportvertex[2] = xmothervertex[9];
3215 xsupportvertex[3] = xsupportvertex[2];
3216 ysupportvertex[0] = yclipvertex[0];
3217 ysupportvertex[1] = yclipvertex[3];
3218 ysupportvertex[2] = ysupportvertex[1];
3219 ysupportvertex[3] = ysupportvertex[0];
3220 TGeoXtru* supportshape = new TGeoXtru(2);
3221 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3222 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3223 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3224 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3225 support->SetLineColor(9);
3226 ///////////////////////////////////////////////////////////////////////
3227 // TGeoXTru Volume definition for Screw
3228 ///////////////////////////////////////////////////////////////////////
3229 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3230 0.5*fgkMountingBlockClibScrewRadius};
3231 Int_t edgesnumber[2] = {50,6};
3232 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3233 +0.5*(ymothervertex[3]-ymothervertex[2])};
3234 TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3235 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3236 clipscrew->SetLineColor(12);
3237 TGeoRotation* screwrot = new TGeoRotation();
3238 screwrot->SetAngles(0.,90.,0.);
3239 TGeoTranslation* screwtrans = new TGeoTranslation();
3240 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3241 0.5*(ymothervertex[3]+ymothervertex[2]),
3242 0.5*fgkSSDMountingBlockWidth+
3243 -0.5*fgkMountingBlockSupportWidth[0]);
3244 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3245 ///////////////////////////////////////////////////////////////////////
3246 // Placing the Volumes
3247 ///////////////////////////////////////////////////////////////////////
3248 ssdmountingblockclip->AddNode(clip,1);
3249 ssdmountingblockclip->AddNode(support,1);
3250 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3251 /////////////////////////////////////////////////////////////
3252 // Deallocating memory
3253 /////////////////////////////////////////////////////////////
3254 delete screwtrans;
3255 delete screwrot;
3256 /////////////////////////////////////////////////////////////
3257 return ssdmountingblockclip;
d7599219 3258}
bf210566 3259///////////////////////////////////////////////////////////////////////////////
3260TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
44285dfa 3261 /////////////////////////////////////////////////////////////
bf210566 3262 // Method generating the Cooling Tube
44285dfa 3263 /////////////////////////////////////////////////////////////
bf210566 3264 TGeoTube** coolingtubeshape[fgkcoolingtubenumber];
3265 for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtubeshape[i] =
3266 new TGeoTube*[2];
9b0c60ab 3267 // Ladder Cooling Tubes
bf210566 3268 coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3269 0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3270 - 2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth));
3271 coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3272 coolingtubeshape[0][0]->GetDz());
3273 coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3274 0.5*(fgkSSDModuleStiffenerPosition[1]
3275 - fgkSSDSensorOverlap));
3276 coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3277 coolingtubeshape[1][0]->GetDz());
3278 coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3279 0.5*fgkSSDModuleStiffenerPosition[1]);
3280 coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3281 coolingtubeshape[2][0]->GetDz());
9b0c60ab 3282 // End Ladder Cooling Tubes
3283 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3284 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3285 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3286 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3287 0.50 * (fgkEndLadderMountingBlockPosition[0]
3288 - fgkendladdercoolingsupportdistance[0]));
3289 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3290 endladdercoolingtubeshape[0][0]->GetDz());
3291 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3292 0.50 * (fgkendladdercoolingsupportdistance[0]
3293 + fgkendladdercoolingsupportdistance[1]
3294 - fgkCoolingTubeSupportWidth));
3295 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3296 endladdercoolingtubeshape[1][0]->GetDz());
3297 endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3298 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
3299 - fgkEndLadderMountingBlockPosition[0]
3300 - fgkendladdercoolingsupportdistance[1]
3301 - fgkCoolingTubeSupportWidth));
3302 endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3303 endladdercoolingtubeshape[2][0]->GetDz());
3304 endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3305 0.50 * (fgkMountingBlockToSensorSupport
3306 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
3307 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
3308 + fgkSSDSensorOverlap
3309 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
3310 - fgkendladdercoolingsupportdistance[2]
3311 - fgkEndLadderMountingBlockPosition[1]
3312 - fgkCoolingTubeSupportWidth));
3313 endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3314 endladdercoolingtubeshape[3][0]->GetDz());
3315 endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3316 0.50 * fgkendladdercoolingsupportdistance[2]);
3317 endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3318 endladdercoolingtubeshape[4][0]->GetDz());
3319 // Ladder Cooling Tubes
bf210566 3320 TGeoVolume** coolingtube[fgkcoolingtubenumber];
3321 for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtube[i] =
3322 new TGeoVolume*[2];
3323 coolingtube[0][0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0][0],
3324 fSSDCoolingTubePhynox);
3325 coolingtube[0][1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[0][1],
3326 fSSDCoolingTubeWater);
3327 coolingtube[1][0] = new TGeoVolume("OuterCoolingTube2",coolingtubeshape[1][0],
3328 fSSDCoolingTubePhynox);
3329 coolingtube[1][1] = new TGeoVolume("InnerCoolingTube2",coolingtubeshape[1][1],
3330 fSSDCoolingTubeWater);
3331 coolingtube[2][0] = new TGeoVolume("OuterCoolingTube3",coolingtubeshape[2][0],
3332 fSSDCoolingTubePhynox);
3333 coolingtube[2][1] = new TGeoVolume("InnerCoolingTube3",coolingtubeshape[2][1],
3334 fSSDCoolingTubeWater);
3335 for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3336 coolingtube[i][0]->SetLineColor(fColorPhynox);
3337 coolingtube[i][1]->SetLineColor(fColorWater);
3338 }
9b0c60ab 3339 // End Ladder Cooling Tubes
3340 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3341 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3342 endladdercoolingtube[i] = new TGeoVolume*[2];
3343 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3344 endladdercoolingtubeshape[0][0],
3345 fSSDCoolingTubePhynox);
3346 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3347 endladdercoolingtubeshape[0][1],
3348 fSSDCoolingTubeWater);
3349 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3350 endladdercoolingtubeshape[1][0],
3351 fSSDCoolingTubePhynox);
3352 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3353 endladdercoolingtubeshape[1][1],
3354 fSSDCoolingTubeWater);
3355 endladdercoolingtube[2][0] = new TGeoVolume("OuterEndLadderCoolingTube3",
3356 endladdercoolingtubeshape[2][0],
3357 fSSDCoolingTubePhynox);
3358 endladdercoolingtube[2][1] = new TGeoVolume("InnerEndlLadderCoolingTube3",
3359 endladdercoolingtubeshape[2][1],
3360 fSSDCoolingTubeWater);
3361 endladdercoolingtube[3][0] = new TGeoVolume("OuterEndLadderCoolingTube4",
3362 endladdercoolingtubeshape[3][0],
3363 fSSDCoolingTubePhynox);
3364 endladdercoolingtube[3][1] = new TGeoVolume("InnerEndlLadderCoolingTube4",
3365 endladdercoolingtubeshape[3][1],
3366 fSSDCoolingTubeWater);
3367 endladdercoolingtube[4][0] = new TGeoVolume("OuterEndLadderCoolingTube5",
3368 endladdercoolingtubeshape[4][0],
3369 fSSDCoolingTubePhynox);
3370 endladdercoolingtube[4][1] = new TGeoVolume("InnerEndlLadderCoolingTube5",
3371 endladdercoolingtubeshape[4][1],
3372 fSSDCoolingTubeWater);
3373 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3374 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3375 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3376 }
bf210566 3377 /////////////////////////////////////////////////////////////
3378 // Virtual Volume containing Cooling Tubes
3379 /////////////////////////////////////////////////////////////
9b0c60ab 3380 // Ladder Cooling Tubes
bf210566 3381 TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber];
3382 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
3383 virtualcoolingtubeshape[i] = new TGeoTube(coolingtubeshape[i][1]->GetRmin(),
3384 coolingtubeshape[i][0]->GetRmax(),
3385 coolingtubeshape[i][0]->GetDz());
3386 TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber];
3387 virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0],
3388 fSSDAir);
3389 virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1],
3390 fSSDAir);
3391 virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2],
3392 fSSDAir);
9b0c60ab 3393 // End Ladder Cooling Tubes
3394 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3395 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3396 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3397 endladdercoolingtubeshape[i][0]->GetRmax(),
3398 endladdercoolingtubeshape[i][0]->GetDz());
3399 TGeoVolume* endladdervirtualcoolingtube[fgkendladdercoolingtubenumber];
3400 endladdervirtualcoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3401 endladdervirtualcoolingtubeshape[0],
3402 fSSDAir);
3403 endladdervirtualcoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3404 endladdervirtualcoolingtubeshape[1],
3405 fSSDAir);
3406 endladdervirtualcoolingtube[2] = new TGeoVolume("EndLadderCoolingTube3",
3407 endladdervirtualcoolingtubeshape[2],
3408 fSSDAir);
3409 endladdervirtualcoolingtube[3] = new TGeoVolume("EndLadderCoolingTube4",
3410 endladdervirtualcoolingtubeshape[3],
3411 fSSDAir);
3412 endladdervirtualcoolingtube[4] = new TGeoVolume("EndLadderCoolingTube5",
3413 endladdervirtualcoolingtubeshape[4],
3414 fSSDAir);
bf210566 3415 TList* coolingtubelist = new TList();
3416 for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3417 virtualcoolingtube[i]->AddNode(coolingtube[i][0],1);
3418 virtualcoolingtube[i]->AddNode(coolingtube[i][1],1);
3419 coolingtubelist->Add(virtualcoolingtube[i]);
d7599219 3420 }
9b0c60ab 3421 endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3422 endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3423 coolingtubelist->Add(endladdervirtualcoolingtube[0]);
3424 endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3425 endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3426 coolingtubelist->Add(endladdervirtualcoolingtube[1]);
3427 endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][0],1);
3428 endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][1],1);
3429 coolingtubelist->Add(endladdervirtualcoolingtube[2]);
3430 endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][0],1);
3431 endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][1],1);
3432 coolingtubelist->Add(endladdervirtualcoolingtube[3]);
3433 endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][0],1);
3434 endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][1],1);
3435 coolingtubelist->Add(endladdervirtualcoolingtube[4]);
bf210566 3436 return coolingtubelist;
d7599219 3437}
bf210566 3438///////////////////////////////////////////////////////////////////////////////
3439TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3440 /////////////////////////////////////////////////////////////
bf210566 3441 // Method generating SSD Cooling Block
44285dfa 3442 /////////////////////////////////////////////////////////////
bf210566 3443 const Int_t kvertexnumber = 8;
3444 ///////////////////////////////////////
3445 // Vertex Positioning for TGeoXTru
3446 ///////////////////////////////////////
3447 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3448 vertexposition[0] = new TVector3(0.0,0.0);
3449 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3450 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3451 vertexposition[1]->Y());
3452 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3453 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3454 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3455 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3456 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3457 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3458 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3459 - fgkSSDCoolingBlockHoleLength[0]
3460 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3461 fgkSSDCoolingBlockHeight[0]
3462 - fgkSSDCoolingBlockHoleRadius[1],
3463 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3464 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3465 - fgkSSDCoolingBlockHoleLength[0]),
3466 vertexposition[6]->Y());
3467 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3468 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3469 Double_t phi = 180.-alpha;
3470 Double_t psi = 180.+2.*alpha;
3471 Double_t deltapsi = psi/nedges;
3472 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3473 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3474 fgkSSDCoolingBlockHoleCenter);
3475 for(Int_t i=0; i<nedges+1; i++){
3476 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3477 radius*SinD(phi+i*deltapsi));
3478 *vertexposition[kvertexnumber+i] += (*transvector);
3479 }
3480 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3481 for(Int_t i=0; i<kvertexnumber; i++)
3482 vertexposition[kvertexnumber+nedges+1+i] =
3483 GetReflection(vertexposition[kvertexnumber-1-i],param);
3484 ///////////////////////////////////////////////////////////////////////
3485 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3486 ///////////////////////////////////////////////////////////////////////
3487 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3488 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3489 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3490 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3491 xvertexpoints[i] = vertexposition[i]->X();
3492 yvertexpoints[i] = vertexposition[i]->Y();
3493 }
3494 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3495 yvertexpoints);
3496 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3497 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3498 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3499 ssdcoolingblockshape,
3500 fSSDAlCoolBlockMedium);
3501 ssdcoolingblock->SetLineColor(fColorAl);
3502 /////////////////////////////////////////////////////////////
3503 // Deallocating memory
3504 /////////////////////////////////////////////////////////////
3505 delete [] vertexposition;
3506 delete xvertexpoints;
3507 delete yvertexpoints;
3508 /////////////////////////////////////////////////////////////
3509 return ssdcoolingblock;
3510}
3511/////////////////////////////////////////////////////////////////////////////////
3512TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
d7599219 3513 ///////////////////////////////////////////////////////
bf210566 3514 const Int_t kssdchipcablesnumber = 2;
3515 const Int_t kssdchipcableslaynumber = 2;
3516 const Int_t kvertexnumber = 4*(nedges+1)+4;
3517 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3518 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3519 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
3520 - fgkSSDChipCablesHeight[0]
3521 - fgkSSDChipCablesHeight[1]);
3522 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3523 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3524 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3525 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3526 - ssdchipcablesradius[0]
3527 - fgkSSDChipCablesWidth[1]
3528 - fgkSSDChipCablesWidth[2]);
3529 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3530 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3531 + fgkSSDChipCablesHeight[1]
3532 + fgkSSDSensorHeight);
d7599219 3533 ///////////////////////////////////////////////////////
bf210566 3534 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3535 ///////////////////////////////////////////////////////
3536 TVector3** vertexposition[kssdchipcableslaynumber];
3537 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3538 new TVector3*[4*(nedges+1)+4];
3539 Double_t ratio[4];
3540 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3541 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3542 / ssdchipcablesradius[0];
3543 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3544 / ssdchipcablesradius[0];
3545 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3546 + fgkSSDChipCablesHeight[1])
3547 / ssdchipcablesradius[0];
3548 Double_t phi = 180.;
3549 Double_t deltaphi = 180./nedges;
3550 Double_t angle = 0.0;
3551 Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3552 Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3553 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3554 xvertexpoints[i] = new Double_t[kvertexnumber];
3555 yvertexpoints[i] = new Double_t[kvertexnumber];
3556 }
3557 TVector3* vertex = new TVector3();
3558 TVector3* transvector[kssdchipcableslaynumber];
3559 transvector[0] = new TVector3(fgkSSDChipWidth,
3560 SSDChipCablesHeigth-ssdchipcablesradius[0]);
3561 transvector[1] = new TVector3();
3562 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
3563 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
3564 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
3565 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3566 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3567 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3568 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3569 transvector[1]->SetY(ssdchipcablesradius[0]
3570 + fgkSSDChipCablesHeight[0]
3571 + fgkSSDChipCablesHeight[1]);
3572 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3573 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
3574 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
3575 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
3576 - i*fgkSSDChipCablesHeight[0]);
3577 vertexposition[i][2*(nedges+1)+2] =
3578 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3579 + fgkSSDChipCablesWidth[1]
3580 + fgkSSDChipCablesWidth[2],
3581 ((1.-i)*fgkSSDChipCablesHeight[i]
3582 + fgkSSDChipCablesHeight[1]));
3583 vertexposition[i][2*(nedges+1)+3] =
3584 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3585 vertexposition[i][2*(nedges+1)+2]->Y()
3586 - fgkSSDChipCablesHeight[i]);
3587 for(Int_t j=0; j<nedges+1; j++){
3588 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3589 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3590 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3591 vertexposition[0][(nedges+1)*i+j+2] =
3592 new TVector3(*vertex+*transvector[i]);
3593 vertexposition[1][(nedges+1)*i+j+2] =
3594 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3595 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3596 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3597 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3598 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3599 new TVector3(vertex->X()*ratio[2*i+1]
3600 + transvector[i]->X(),
3601 vertex->Y()*ratio[2*i+1]
3602 + transvector[i]->Y());
3603 }
3604 }
3605 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3606 for(Int_t j=0; j<kvertexnumber; j++){
3607 xvertexpoints[i][j] = vertexposition[i][j]->X();
3608 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3609 }
3610 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3611 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3612 xvertexpoints[i],yvertexpoints[i]);
3613 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3614 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3615 ssdchipcable[kssdchipcablesnumber*k+i] =
3616 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3617 ssdchipcableshape[kssdchipcablesnumber*k+i],
3618 (kssdchipcablesnumber*k+i)%2==0?
3619 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3620 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3621 }
3622 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3623 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3624 }
44285dfa 3625 /////////////////////////////////////////////////////////////
bf210566 3626 // Mother Volume definition
3627 /////////////////////////////////////////////////////////////
3628 Double_t ssdchipseparation = fgkSSDSensorLength
3629 - 2.*fgkSSDModuleStiffenerPosition[1]
3630 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3631 - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
3632 Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth};
3633 Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0]
3634 +fgkSSDChipCablesWidth[1]
3635 +fgkSSDChipCablesWidth[2]);
3636 Double_t dy = fgkSSDChipCablesLength[1];
3637 Double_t dz = SSDChipCablesHeigth;
3638 TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
3639 TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother",
3640 ssdchipcablesmotherbox,fSSDAir);
3641 /////////////////////////////////////////////////////////////
3642 // Rotation and Translation Definition for positioning
3643 /////////////////////////////////////////////////////////////
3644 TGeoRotation* ssdchipcablesrot[5];
3645 ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
3646 ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
3647 ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
3648 ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
3649 ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
3650 TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,
3651 0.,0.,ssdchipcablesrot[2]);
3652 ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]);
3653 ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]);
3654 ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans);
3655 ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans);
3656 /////////////////////////////////////////////////////////////
3657 // Deallocating memory
3658 /////////////////////////////////////////////////////////////
3659 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3660 delete [] xvertexpoints[i];
3661 delete [] yvertexpoints[i];
3662 }
3663 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3664 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3665 delete vertex;
3666 delete ssdchipcablesrot[0];
3667 delete ssdchipcablesrot[1];
3668 delete ssdchipcablesrot[3];
3669 /////////////////////////////////////////////////////////////
3670 return ssdchipcablesmother;
d7599219 3671}
bf210566 3672///////////////////////////////////////////////////////////////////////////////
3673TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
3674 /////////////////////////////////////////////////////////////
3675 // SSD Chip Assembly
3676 /////////////////////////////////////////////////////////////
3677 TGeoVolume* ssdchipassembly = GetSSDChips();
3678 TList* ssdchipsystemlist = new TList();
3679 const Int_t knedges = 20;
3680 const Int_t kchipsystemnumber = 2;
3681 /////////////////////////////////////////////////////////////
3682 // Mother Volume containing SSDChipSystem
3683 /////////////////////////////////////////////////////////////
3684 TGeoXtru* chipsystemothershape[kchipsystemnumber];
3685 for(Int_t i=0; i<kchipsystemnumber; i++) chipsystemothershape[i] = new TGeoXtru(2);
3686 const Int_t kmothervertexnumber = 12;
3687 Double_t xmothervertex[kchipsystemnumber][kmothervertexnumber];
3688 Double_t ymothervertex[kchipsystemnumber][kmothervertexnumber];
3689 Double_t ssdchipcablesradius[kchipsystemnumber];
3690 Double_t ssdchipseparation = fgkSSDSensorLength
3691 - 2.*fgkSSDModuleStiffenerPosition[1]
3692 - 2.*(fgkSSDStiffenerWidth
3693 - fgkSSDStiffenerToChipDist-0.5*fgkSSDChipWidth);
3694 for(Int_t i=0; i<kchipsystemnumber; i++)
3695 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
3696 - fgkSSDChipCablesHeight[0]
3697 - fgkSSDChipCablesHeight[1]);
3698 ///////////////////////
3699 // Setting the vertices
3700 ///////////////////////
3701 xmothervertex[0][0] = -0.5*fgkSSDChipCablesLength[1];
3702 xmothervertex[0][1] = xmothervertex[0][0];
3703 xmothervertex[0][2] = (fgkSSDChipNumber-1)*(fgkSSDChipLength
3704 + fgkSSDChipSeparationLength)+0.5*fgkSSDChipCablesLength[1];
3705 xmothervertex[0][3] = xmothervertex[0][2];
3706 xmothervertex[0][4] = 0.5*fgkSSDChipCablesLength[1];
3707 xmothervertex[0][5] = xmothervertex[0][4];
3708 xmothervertex[0][6] = xmothervertex[0][2]-0.5*fgkSSDChipCablesLength[1];
3709 xmothervertex[0][7] = xmothervertex[0][6];
3710 xmothervertex[0][8] = 0.0;
3711 xmothervertex[0][9] = xmothervertex[0][8];
3712 xmothervertex[0][10] = xmothervertex[0][4];
3713 xmothervertex[0][11] = xmothervertex[0][10];
3714 for(Int_t i=0; i<kmothervertexnumber; i++)
3715 xmothervertex[1][i] = xmothervertex[0][i];
3716 for(Int_t i=0; i<kchipsystemnumber; i++){
3717 ymothervertex[i][0] = -0.5*fgkSSDChipWidth-ssdchipcablesradius[i]
3718 - fgkSSDChipCablesWidth[1]-fgkSSDChipCablesWidth[2];
3719 ymothervertex[i][1] = ssdchipseparation-ymothervertex[i][0];
3720 ymothervertex[i][2] = ymothervertex[i][1];
3721 ymothervertex[i][3] = ymothervertex[i][0];
3722 ymothervertex[i][4] = ymothervertex[i][0];
3723 ymothervertex[i][5] = 0.5*fgkSSDChipWidth;
3724 ymothervertex[i][6] = ymothervertex[i][5];
3725 ymothervertex[i][7] = ssdchipseparation-0.5*fgkSSDChipWidth;
3726 ymothervertex[i][8] = ymothervertex[i][7];
3727 ymothervertex[i][9] = ymothervertex[i][5];
3728 ymothervertex[i][10] = ymothervertex[i][5];
3729 ymothervertex[i][11] = ymothervertex[i][4];
3730 }
3731 //////////////////////////////////////////////////////////
3732 TGeoVolume* chipsystemother[kchipsystemnumber];
3733 const char* chipsytemothername[kchipsystemnumber] =
3734 {"SSDChipSytemother1","SSDChipSytemother2"};
3735 for(Int_t i=0; i<kchipsystemnumber; i++){
3736 chipsystemothershape[i]->DefinePolygon(kmothervertexnumber,
3737 xmothervertex[i],ymothervertex[i]);
3738 chipsystemothershape[i]->DefineSection(0,-fgkSSDChipCablesHeight[i+2]
3739 -0.5*fgkSSDChipHeight);
3740 chipsystemothershape[i]->DefineSection(1,0.5*fgkSSDChipHeight);
3741 chipsystemother[i] = new TGeoVolume(chipsytemothername[i],
3742 chipsystemothershape[i],fSSDAir);
3743 }
44285dfa 3744 /////////////////////////////////////////////////////////////
bf210566 3745 // SSD Chip Cables
3746 /////////////////////////////////////////////////////////////
3747 TGeoVolume* ssdchipcables[kchipsystemnumber];
3748 TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
3749 TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
3750 TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
3751 //////////////////
3752 for(Int_t i=0; i<kchipsystemnumber; i++){
3753 ssdchipcables[i] =
3754 GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
3755 ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
3756 ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
3757 ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
3758 }
3759 for(Int_t i=0; i<kchipsystemnumber; i++){
3760 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3761 ssdchipcablestrans[i][j] = new TGeoTranslation();
3762 ssdchipcablesrot[i][j] = new TGeoRotation();
3763 ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
3764 ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
3765 ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
3766 + fgkSSDChipSeparationLength),
3767 0.5*fgkSSDChipWidth,
3768 - 0.5*fgkSSDChipHeight
3769 - fgkSSDChipCablesHeight[i+2]);
3770 ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
3771 ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
3772 chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
3773
3774 }
3775 chipsystemother[i]->AddNode(ssdchipassembly,i+1);
3776 ssdchipsystemlist->Add(chipsystemother[i]);
3777 }
3778 /////////////////////////////////////////////////////////////
3779 // Deallocating memory
3780 /////////////////////////////////////////////////////////////
3781 for(Int_t i=0; i<kchipsystemnumber; i++){
3782 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3783 delete ssdchipcablesrot[i][j];
3784 delete ssdchipcablestrans[i][j];
3785 }
3786 delete ssdchipcablesrot[i];
3787 delete ssdchipcablestrans[i];
3788 }
3789 /////////////////////////////////////////////////////////////
3790 return ssdchipsystemlist;
d7599219 3791}
bf210566 3792///////////////////////////////////////////////////////////////////////////////
3793TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
44285dfa 3794 /////////////////////////////////////////////////////////////
bf210566 3795 // SSD Chip Assembly Generation
3796 /////////////////////////////////////////////////////////////
3797 const Int_t kssdchiprownumber = 2;
3798 TGeoBBox* ssdchipcompshape[2];
3799 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3800 0.5*fgkSSDChipLength,
3801 0.5*fgkSSDChipWidth,
3802 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3803 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3804 0.5*fgkSSDChipLength,
3805 0.5*fgkSSDChipWidth,
3806 0.5*fgkSSDChipGlueHeight);
3807 TGeoVolume* ssdchipcomp[2];
3808 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3809 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3810 fSSDChipGlueMedium);
3811 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3812 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3813 TGeoTranslation* ssdchipcomptrans[2];
3814 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3815 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3816 /////////////////////////////////////////////////////////////
3817 // Virtual Volume containing SSDChip
3818 /////////////////////////////////////////////////////////////
3819 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3820 0.5*fgkSSDChipWidth,
3821 0.5*fgkSSDChipHeight);
3822 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
3823 /////////////////////////////////////////////////////////////
3824 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3825 Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
3826 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3827 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3828 - 0.5*fgkSSDChipWidth)};
3829 /////////////////////////////////////////////////////////////
3830 // Virtual Volume containing SSDChipAssembly
3831 /////////////////////////////////////////////////////////////
3832 TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
3833 const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
3834 Double_t xmothervertex[kssdmothervertexnumber];
3835 Double_t ymothervertex[kssdmothervertexnumber];
3836 ///////////////////////
3837 // Setting the vertices
3838 ///////////////////////
3839 xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
3840 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
3841 - ymothervertex[0];
3842 xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
3843 ymothervertex[2] = ymothervertex[1];
3844 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
3845 xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
3846 ymothervertex[4] = ymothervertex[0];
3847 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
3848 xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
3849 + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
3850 ymothervertex[6] = ymothervertex[5];
3851 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
3852 - fgkSSDChipWidth;
3853 xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3854 ymothervertex[8] = ymothervertex[7];
3855 xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3856 ymothervertex[9] = ymothervertex[6];
3857 xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
3858 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
3859 //////////////////////////////////////////////////////////
3860 ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
3861 xmothervertex,ymothervertex);
3862 ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
3863 ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
3864 TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
3865 ssdchipmothershape,fSSDAir);
3866 /////////////////////////////////////////////////////////////
3867 for(Int_t i=0; i<kssdchiprownumber; i++)
3868 for(Int_t j=0; j<fgkSSDChipNumber; j++)
3869 ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
3870 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
3871 return ssdchipmother;
d7599219 3872}
bf210566 3873/////////////////////////////////////////////////////////////////////////////////
3874TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3875 /////////////////////////////////////////////////////////////
bf210566 3876 // Method returning a List containing pointers to Ladder Cable Volumes
44285dfa 3877 /////////////////////////////////////////////////////////////
bf210566 3878 const Int_t kladdercablesegmentnumber = 2;
3879 /////////////////////////////////////////
3880 // LadderSegmentBBox Volume
3881 /////////////////////////////////////////
3882 TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
3883 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3884 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3885 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3886 new TGeoBBox(laddercablesegmentbboxshapename[i],
3887 0.5*fgkSSDFlexWidth[0],
3888 0.5*fgkSSDLadderCableWidth,
3889 0.5*fgkSSDFlexHeight[i]);
3890 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3891 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3892 TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3893 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3894 laddercablesegmentbbox[i] =
3895 new TGeoVolume(laddercablesegmentbboxname[i],
3896 laddercablesegmentbboxshape[i],
3897 (i==0?fSSDAlTraceLadderCableMedium:
3898 fSSDKaptonLadderCableMedium));
3899 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3900 fColorPolyhamide);
3901 }
3902 TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
3903 laddercablesegmentbboxtrans[0] =
3904 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3905 0.5*fgkSSDFlexWidth[0],
3906 0.5*fgkSSDLadderCableWidth,
3907 0.5*fgkSSDFlexHeight[0]);
3908 laddercablesegmentbboxtrans[1] =
3909 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3910 0.5*fgkSSDFlexWidth[0],
3911 0.5*fgkSSDLadderCableWidth,
3912 fgkSSDFlexHeight[0]
3913 +0.5*fgkSSDFlexHeight[1]);
3914 TGeoVolume* laddercablesegmentbboxassembly =
3915 new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
3916 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3917 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3918 laddercablesegmentbboxtrans[i]);
3919/////////////////////////////////////////
3920// LadderSegmentArb8 Volume
3921/////////////////////////////////////////
3922 const Int_t kvertexnumber = 4;
3923 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3924 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3925 new TVector3*[kvertexnumber];
3926//Shape Vertex Positioning
3927 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3928 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3929 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3930 i*fgkSSDFlexHeight[0]);
3931 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3932 + fgkSSDFlexHeight[1]
3933 + i*fgkSSDFlexHeight[0]);
3934 laddercablesegmentvertexposition[i][3] =
3935 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3936 laddercablesegmentvertexposition[i][2]->Y());
3937 }
3938 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3939 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3940 char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3941 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3942 TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3943 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3944 GetArbShape(laddercablesegmentvertexposition[i],
3945 laddercablesegmentwidth[i],
3946 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3947 laddercablesegmentarbshapename[i]);
3948 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3949 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3950 TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3951 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3952 laddercablesegmentarb[i] =
3953 new TGeoVolume(laddercablesegmentarbname[i],
3954 laddercablesegmentarbshape[i],
3955 (i==0?fSSDAlTraceLadderCableMedium:
3956 fSSDKaptonLadderCableMedium));
3957 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3958 fColorPolyhamide);
d7599219 3959}
bf210566 3960 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3961 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3962 90.,90,-90.);
3963 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3964 0.,90.,0.);
3965 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3966 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3967 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3968 + fgkSSDFlexWidth[0],0.,0.,
3969 new TGeoRotation((*laddercablesegmentarbrot[1])
3970 *(*laddercablesegmentarbrot[0])));
3971 TGeoVolume* laddercablesegmentarbassembly =
3972 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3973 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3974 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3975 laddercablesegmentarbcombitrans);
3976/////////////////////////////////////////
3977// End Ladder Cable Volume
3978/////////////////////////////////////////
3979 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3980 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3981 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3982 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3983 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3984 0.5*ssdendladdercablelength,
3985 0.5*fgkSSDLadderCableWidth,
3986 0.5*fgkSSDFlexHeight[i]);
3987 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3988 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3989 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3990 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3991 ladderendcablesegmentbbox[i] =
3992 new TGeoVolume(ladderendcablesegmentbboxname[i],
3993 ladderendcablesegmentbboxshape[i],
3994 (i==0?fSSDAlTraceLadderCableMedium:
3995 fSSDKaptonLadderCableMedium));
3996 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3997 fColorPolyhamide);
3998 }
3999 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
4000 ladderendcablesegmentbboxtrans[0] =
4001 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
4002 0.5*ssdendladdercablelength,
4003 0.5*fgkSSDLadderCableWidth,
4004 0.5*fgkSSDFlexHeight[0]);
4005 ladderendcablesegmentbboxtrans[1] =
4006 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
4007 0.5*ssdendladdercablelength,
4008 0.5*fgkSSDLadderCableWidth,
4009 fgkSSDFlexHeight[0]
4010 +0.5*fgkSSDFlexHeight[1]);
4011 TGeoVolume* ladderendcablesegmentbboxassembly =
4012 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
4013 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
4014 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
4015 ladderendcablesegmentbboxtrans[i]);
4016/////////////////////////////////////////
4017 TList* laddercablesegmentlist = new TList();
4018 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
4019 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
4020 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
4021 return laddercablesegmentlist;
4022 }
4023/////////////////////////////////////////////////////////////////////////////////
4024TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 4025 /////////////////////////////////////////////////////////////
bf210566 4026 // Method generating Ladder Cable Volumes Assemblies
44285dfa 4027 /////////////////////////////////////////////////////////////
bf210566 4028 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
4029 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
4030 for(Int_t i=0; i<n; i++){
4031 TGeoTranslation* laddercabletrans = new TGeoTranslation(
4032 i*(fgkCarbonFiberJunctionWidth),
4033 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4034 i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4035 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
4036 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
d7599219 4037 }
bf210566 4038 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
4039 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4040 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4041 (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4042 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
4043 return laddercable;
4044}
4045/////////////////////////////////////////////////////////////////////////////////
4046TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
4047 /////////////////////////////////////////////////////////////
4048 // Method generating Ladder Cable Volumes Assembly
4049 /////////////////////////////////////////////////////////////
4050 TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
4051 char laddercabletransname[30];
4052 for(Int_t i=0; i<n; i++){
4053 sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
4054 laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
4055 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
d7599219 4056 }
bf210566 4057 return laddercableassembly;
4058}
4059/////////////////////////////////////////////////////////////////////////////////
4060TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
4061 /////////////////////////////////////////////////////////////
4062 // Method generating Ladder Cable List Assemblies
4063 /////////////////////////////////////////////////////////////
4064 const Int_t kladdercableassemblynumber = 2;
4065 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
4066 TGeoVolume* ladderCable[kladdercableassemblynumber];
4067 char laddercableassemblyname[30];
4068 TList* laddercableassemblylist = new TList();
4069 for(Int_t i=0; i<kladdercableassemblynumber; i++){
4070 sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
4071 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
4072 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
4073 new TGeoCombiTrans((n-1)
4074 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4075 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
4076 0.,new TGeoRotation("",180,0.,0.)));
4077 laddercableassemblylist->Add(ladderCable[i]);
4078}
4079 return laddercableassemblylist;
4080}
4081///////////////////////////////////////////////////////////////////////////////
4082void AliITSv11GeometrySSD::SetLadderSegment(){
4083 /////////////////////////////////////////////////////////////
4084 // Method Generating Ladder Segment Array
4085 /////////////////////////////////////////////////////////////
4086 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
4087 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
4088 if(!fCreateMaterials) CreateMaterials();
4089 if(!fTransformationMatrices) CreateTransformationMatrices();
4090 if(!fBasicObjects) CreateBasicObjects();
4091 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
4092 // Placing Carbon Fiber Support
4093 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
4094 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4095 fcarbonfibersupportmatrix[j]);
4096 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4097 fcarbonfibersupportmatrix[j]);
d7599219 4098 }
bf210566 4099 // Placing Carbon Fiber Junction
4100 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
4101 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
4102 fcarbonfiberjunctionmatrix[j]);
4103 // Placing Carbon Fiber Lower Support
4104 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++)
4105 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
4106 fcarbonfiberlowersupportrans[j]);
4107 // Placing SSD Sensor Support
4108 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
4109 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
4110 fssdsensorsupport[1][i],
4111 j+1,fssdsensorsupportmatrix[j]);
4112 // Placing SSD Cooling Tube Support
4113 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
4114 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4115 fcoolingtubesupportmatrix[j]);
4116 // Placing SSD Cooling Tube
4117 for(Int_t j=0; j<2; j++)
4118 for(Int_t k=0; k<2; k++){
4119 fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]);
4120 fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]);
4121 }
4122 // Placing SSD Hybrid
4123 switch(i){
4124 case 0:
4125 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
4126 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4127 break;
4128 case 1:
4129 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
4130 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4131 break;
4132 }
4133 // Placing Cooling Block System
4134 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
4135 // Placing SSD Flex
4136 for(Int_t j=0; j<fgkflexnumber; j++){
4137 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
4138 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
4139 }
4140 }
d7599219 4141}
bf210566 4142///////////////////////////////////////////////////////////////////////////////
4143void AliITSv11GeometrySSD::SetEndLadderSegment(){
4144 /////////////////////////////////////////////////////////////
4145 // Method Generating End Ladder
4146 /////////////////////////////////////////////////////////////
4147 // End Ladder Carbon Fiber Junction
4148 /////////////////////////////////////////////////////////////
4149 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
4150 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
4151 if(!fCreateMaterials) CreateMaterials();
4152 if(!fTransformationMatrices) CreateTransformationMatrices();
4153 if(!fBasicObjects) CreateBasicObjects();
4154 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
4155 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
4156 fendladdersegment[i]->AddNode(j==2 ?
4157 fendladdercarbonfiberjunction[i][1] :
4158 fendladdercarbonfiberjunction[i][0],
4159 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
4160 }
4161 /////////////////////////////////////////////////////////////
4162 // End Ladder Carbon Fiber Support
4163 /////////////////////////////////////////////////////////////
4164 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
4165 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
4166 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4167 fendladdercarbonfibermatrix[i][j]);
4168 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4169 fendladdercarbonfibermatrix[i][j]);
4170 }
4171 /////////////////////////////////////////////////////////////
4172 // End Ladder Mounting Block
4173 /////////////////////////////////////////////////////////////
9b0c60ab 4174 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4175 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
4176 fendladdermountingblockcombitrans[i]);
4177 /////////////////////////////////////////////////////////////
e5bf64ae 4178 // End Ladder Mounting Block Clip
9b0c60ab 4179 /////////////////////////////////////////////////////////////
4180 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4181 for(Int_t j=0; j<2; j++)
4182 fendladdersegment[i]->AddNode(fendladdermountingblockclip,i+1,
4183 fendladdermountingblockclipmatrix[i][j]);
bf210566 4184 /////////////////////////////////////////////////////////////
4185 // End Ladder Lower Supports
44285dfa 4186 /////////////////////////////////////////////////////////////
bf210566 4187 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
4188 fendladderlowersupptrans[0]);
4189 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
4190 fendladderlowersupptrans[1]);
4191 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
4192 fendladderlowersupptrans[2]);
9b0c60ab 4193 /////////////////////////////////////////////////////////////
4194 // End Ladder Cooling Tube Support
4195 /////////////////////////////////////////////////////////////
4196 for(Int_t i=0; i<2; i++)
4197 for(Int_t j=0; j<(i==0?4:2); j++)
4198 fendladdersegment[i]->AddNode(fcoolingtubesupport,
4199 j+1,fendladdercoolingtubesupportmatrix[i][j]);
4200 /////////////////////////////////////////////////////////////
4201 // End Ladder Cooling Tube Support
4202 /////////////////////////////////////////////////////////////
4203 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
4204 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
4205 fendladdersegment[0]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[0][2]);
4206 fendladdersegment[0]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[0][3]);
4207 fendladdersegment[0]->AddNode(fendladdercoolingtube[2],1,fendladdercoolingtubematrix[0][4]);
4208 fendladdersegment[0]->AddNode(fendladdercoolingtube[2],2,fendladdercoolingtubematrix[0][5]);
4209 fendladdersegment[1]->AddNode(fendladdercoolingtube[3],1,fendladdercoolingtubematrix[1][0]);
4210 fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);
4211 fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);
4212 fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);
6727e2db 4213 // fendladdersegment[0]->CheckOverlaps(0.01);
4214 // fendladdersegment[1]->CheckOverlaps(0.01);
bf210566 4215}
4216///////////////////////////////////////////////////////////////////////////////
4217void AliITSv11GeometrySSD::SetLadder(){
4218 /////////////////////////////////////////////////////////////
4219 // Method Generating Ladder of Layer 5 and 6
44285dfa 4220 /////////////////////////////////////////////////////////////
bf210566 4221 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
4222 fgkSSDLay6SensorsNumber};
4223 /////////////////////////////////////////////////////////////////////////////
4224 /// Generating Ladder Mother Volume Containing Ladder
4225 /////////////////////////////////////////////////////////////////////////////
4226 TGeoXtru* laddershape[fgkladdernumber];
4227 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
4228 const Int_t kmothervertexnumber = 8;
4229 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
4230 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
4231 ///////////////////////
4232 // Setting the vertices
4233 ///////////////////////
4234 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
4235 * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
4236 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
4237 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
4238 xmothervertex[0][1] = xmothervertex[0][0];
4239 ymothervertex[0][1] = 0.0;
4240 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
4241 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
4242 ymothervertex[0][2] = ymothervertex[0][1];
4243 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
4244 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
4245 xmothervertex[0][4] = -xmothervertex[0][3];
4246 ymothervertex[0][4] = ymothervertex[0][3];
4247 xmothervertex[0][5] = -xmothervertex[0][2];
4248 ymothervertex[0][5] = ymothervertex[0][2];
4249 xmothervertex[0][6] = -xmothervertex[0][1];
4250 ymothervertex[0][6] = ymothervertex[0][1];
4251 xmothervertex[0][7] = -xmothervertex[0][0];
4252 ymothervertex[0][7] = ymothervertex[0][0];
4253 for(Int_t i=0; i<kmothervertexnumber; i++){
4254 xmothervertex[1][i] = xmothervertex[0][i];
4255 ymothervertex[1][i] = ymothervertex[0][i];
4256 }
4257 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4258 for(Int_t i=0; i<fgkladdernumber; i++){
4259 laddershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
4260 ymothervertex[i]);
4261 laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4262 laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4263 +fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4264 fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir);
9b0c60ab 4265 fladder[i]->SetLineColor(4);
bf210566 4266 }
4267///////////////////////////////////////////////////////////////////////////
4268 if(!fCreateMaterials) CreateMaterials();
4269 if(!fTransformationMatrices) CreateTransformationMatrices();
4270 if(!fBasicObjects) CreateBasicObjects();
4271 SetLadderSegment();
4272 SetEndLadderSegment();
4273 for(Int_t i=0; i<fgkladdernumber; i++){
4274 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4275 //////////////////////////
4276 /// Placing Ladder Segment
4277 //////////////////////////
4278 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4279 fladdersegment[i==0 ? 1 : 0],
4280 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4281 //////////////////////////
4282 /// Placing SSD Sensor
4283 //////////////////////////
4284 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4285 fssdsensormatrix[i][j]);
4286 }
4287 ///////////////////////////////
4288 /// Placing End Ladder Segment
4289 ///////////////////////////////
4290 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4291 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4292 }
d7599219 4293/////////////////////////////////////////////////////////////////////////////
4294/// Placing Ladder Cables
4295/////////////////////////////////////////////////////////////////////////////
bf210566 4296 Int_t sidecablenumber[2][2];
4297 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4298 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4299 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4300 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4301 Double_t carbonfibertomoduleposition[3];
4302 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4303 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4304 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4305 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4306 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4307 - fgkSSDSensorCenterSupportThickness[0]);
4308 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4309 + 0.5*fgkCoolingTubeSupportHeight
4310 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4311 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4312 Double_t ssdendladdercablelength[4];
4313 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4314 + fgkSSDSensorLength
4315 - fgkSSDModuleStiffenerPosition[1]
4316 - fgkSSDStiffenerWidth
4317 - fgkSSDFlexWidth[0]
bf210566 4318 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4319 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4320 + fgkSSDModuleStiffenerPosition[1]
4321 + fgkSSDStiffenerWidth
bf210566 4322 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4323 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4324 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4325 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4326 - kendladdercablecorrection;
44285dfa 4327 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4328 + carbonfibertomoduleposition[1]
d7599219 4329 - fgkSSDModuleStiffenerPosition[1]
4330 - fgkSSDStiffenerWidth)
bf210566 4331 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
44285dfa 4332 TList* laddercableassemblylist[4];
4333 const Int_t kendladdercablesnumber = 4;
bf210566 4334 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4335 for(Int_t j=0; j<kendladdercablesnumber; j++){
4336 laddercableassemblylist[j] =
4337 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4338 ssdendladdercablelength[j]);
4339 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4340 j<2?1:2,fladdercablematrix[i][j]);
4341 }
9b0c60ab 4342// fladder[0]->CheckOverlaps(0.01);
4343// fladder[1]->CheckOverlaps(0.01);
bf210566 4344}
4345////////////////////////////////////////////////////////////////////////////////
4346void AliITSv11GeometrySSD::SetLayer(){
d7599219 4347////////////////////////////////////////////////////////////////////////////////
bf210566 4348 // Creating Ladder of Layer 5 and Layer 6
4349 /////////////////////////////////////////////////////////////
4350 if(!fCreateMaterials) CreateMaterials();
4351 if(!fTransformationMatrices) CreateTransformationMatrices();
4352 if(!fBasicObjects) CreateBasicObjects();
4353 SetLadder(); // Generating the ladder of Layer5 and Layer6
4354 const Int_t kssdlayladdernumber[fgklayernumber] =
4355 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4356 /////////////////////////////////////////////////////////////
4357 // Generating mother volumes for Layer5 and Layer6
4358 /////////////////////////////////////////////////////////////
e5bf64ae 4359 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4360 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
bf210566 4361 Int_t *ladderindex[fgklayernumber];
4362 Int_t index[fgklayernumber] = {8,9};
4363 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4364 for(Int_t i=0; i<fgklayernumber; i++)
4365 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4366 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4367 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4368 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4369 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4370 }
44285dfa 4371 /////////////////////////////////////////////////////////////
bf210566 4372 // Deallocating memory
4373 /////////////////////////////////////////////////////////////
9b0c60ab 4374 for(Int_t i=0; i<fgklayernumber; i++) delete ladderindex[i];
d7599219 4375}
4376////////////////////////////////////////////////////////////////////////////////
4377void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4378 /////////////////////////////////////////////////////////////
4379 // Insert the layer 5 in the mother volume.
4380 /////////////////////////////////////////////////////////////
4381 if (! moth) {
4382 printf("Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!\n");
4383 return;
4384 };
bf210566 4385 if(!fSSDLayer5) SetLayer();
4386 fMotherVol = moth;
4387 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4388 + fgkLay5CenterITSPosition);
4389 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4390 }
d7599219 4391////////////////////////////////////////////////////////////////////////////////
4392void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4393 /////////////////////////////////////////////////////////////
4394 // Insert the layer 6 in the mother volume.
4395 /////////////////////////////////////////////////////////////
4396 if (! moth) {
4397 printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4398 return;
4399 };
bf210566 4400 if(!fSSDLayer6) SetLayer();
4401 fMotherVol = moth;
4402 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4403 + fgkLay6CenterITSPosition);
4404 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4405 }
bf210566 4406 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4407 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4408 /////////////////////////////////////////////////////////////
4409 // Method generating the Arc structure of Ladder Support
4410 /////////////////////////////////////////////////////////////
4411 const Int_t kssdlayladdernumber[fgklayernumber] =
4412 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4413 Double_t mountingsupportedge[fgklayernumber];
4414 Double_t mountingblockratio[fgklayernumber];
4415 Double_t theta[fgklayernumber];
4416 Double_t phi[fgklayernumber];
4417 Double_t psi0[fgklayernumber];
4418 Double_t deltapsi[fgklayernumber];
4419 TVector3* mountingsupportedgevector[fgklayernumber];
4420 for(Int_t i=0; i<fgklayernumber; i++){
4421 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4422 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4423 *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4424 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4425 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4426 / kssdlayladdernumber[i])));
4427 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4428 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4429 mountingsupportedgevector[i] = new TVector3();
4430 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4431 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(1.
4432 -TMath::Power(mountingsupportedgevector[i]->X()
4433 / fgkMountingBlockSupportRadius[i],2)));
4434 psi0[i] = 0.5*TMath::Pi()-phi[i];
4435 deltapsi[i] = (theta[i]+phi[i])/nedges;
4436 }
4437 TVector3** vertex[fgklayernumber];
4438 TList* vertexlist[fgklayernumber];
4439 Int_t indexedge[fgklayernumber] = {0,0};
4440 for(Int_t i=0; i<fgklayernumber; i++){
4441 vertex[i] = new TVector3*[nedges+1];
4442 vertexlist[i] = new TList();
4443 }
4444 for(Int_t i=0; i<fgklayernumber; i++){
4445 for(Int_t j=0; j<nedges+1; j++){
4446 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4447 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4448 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4449 vertexlist[i]->Add(vertex[i][j]);
4450 }
4451 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4452 }
4453 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4454 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4455 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4456 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4457 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4458 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4459 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4460 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4461 for(Int_t i=0; i<fgklayernumber; i++){
4462 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4463 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4464 xcentervertex[i] = new Double_t[indexedge[i]+3];
4465 ycentervertex[i] = new Double_t[indexedge[i]+3];
4466 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4467 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4468 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4469 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4470 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4471 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4472 ((TVector3*)vertexlist[i]->At(j))->X();
4473 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4474 ((TVector3*)vertexlist[i]->At(j))->Y();
4475 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4476 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4477 if(j<indexedge[i]+1){
4478 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4479 ((TVector3*)vertexlist[i]->At(j))->X();
4480 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4481 ((TVector3*)vertexlist[i]->At(j))->Y();
4482 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4483 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4484 }
4485 }
4486 xsidevertex[i][1] = xsidevertex[i][0];
4487 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4488 xsidevertex[i][2] = xsidevertex[i][3];
4489 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4490 xcentervertex[i][1] = xcentervertex[i][0];
4491 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4492 xcentervertex[i][2] = xcentervertex[i][3];
4493 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4494 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4495 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4496 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4497 ycenterlowervertex[i][0] = ysidevertex[i][0];
4498 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4499 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4500 }
4501 /////////////////////////////////////////////////////////////
4502 // Building the Arc Structure of Ladder Supports
4503 /////////////////////////////////////////////////////////////
4504 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4505 TGeoXtru* centermountingsupportshape[fgklayernumber];
4506 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4507 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4508 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4509 TGeoVolume* centermountingblocksupport[fgklayernumber];
4510 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4511 TGeoVolume* centerladdersupportpiece[fgklayernumber];
4512 char sidemountingblockname[40];
4513 char centermountingblockname[40];
4514 char sideladdersupportpiecename[40];
4515 char centerladdersupportpiecename[40];
4516 for(Int_t i=0; i<fgklayernumber; i++){
4517 sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4518 sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4519 sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4520 sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4521 sidemountingblocksupportshape[i] = new TGeoXtru(2);
4522 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4523 xsidevertex[i],ysidevertex[i]);
4524 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4525 -fgkMountingBlockSupportWidth[0]);
4526 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4527 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4528 sidemountingblocksupportshape[i],
4529 fSSDAlCoolBlockMedium);
4530 sidemountingblocksupport[i]->SetLineColor(9);
4531 centermountingsupportshape[i] = new TGeoXtru(2);
4532 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4533 xcentervertex[i],ycentervertex[i]);
4534 centermountingsupportshape[i]->DefineSection(0,0.);
4535 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4536 -fgkMountingBlockSupportWidth[0]);
4537 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4538 centermountingsupportshape[i],
4539 fSSDAlCoolBlockMedium);
4540 centermountingblocksupport[i]->SetLineColor(9);
4541 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4542 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4543 xsidelowervertex[i],ysidelowervertex[i]);
4544 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4545 -fgkMountingBlockSupportWidth[0]);
4546 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4547 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4548 sideladdersupportpieceshape[i],
4549 fSSDSupportRingAl);
4550 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4551 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4552 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4553 xcenterlowervertex[i],ycenterlowervertex[i]);
4554 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4555 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4556 -fgkMountingBlockSupportWidth[0]);
4557 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4558 centerladdersupportpieceshape[i],
4559 fSSDSupportRingAl);
4560 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4561 }
4562 /////////////////////////////////////////////////////////////
4563 // Building the Up Structure of Ladder Supports
4564 /////////////////////////////////////////////////////////////
4565 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4566 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4567 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4568 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4569 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4570 //////////////////////////////////////////////////////////
4571 // Setting the volume for TGeoXtru Mounting Block Piece
4572 //////////////////////////////////////////////////////////
4573 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4574 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4575 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4576 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4577 TGeoVolume* mountingblockpieceup[fgklayernumber];
4578 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4579 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4580 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4581 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
4582 char mountingblockpiecedownname[34];
4583 char mountingblockpieceupname[34];
4584 for(Int_t i=0; i<fgklayernumber; i++){
4585 ///////////////////////////
4586 // Mounting Block Down Vertex
4587 ///////////////////////////
4588 mountingblockpiecedownshape[i] = new TGeoXtru(2);
4589 sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4590 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4591 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4592 + fgkMountingBlockSupportDownHeight;
4593 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4594 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4595 + fgkSSDMountingBlockHeight[1]
4596 - 0.5*fgkCoolingTubeSupportHeight
4597 - fgkSSDModuleCoolingBlockToSensor;
4598 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4599 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4600 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4601 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4602 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4603 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4604 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4605 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4606 + fgkSSDMountingBlockHeight[2]
4607 - fgkSSDMountingBlockHeight[0];
4608 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4609 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4610 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4611 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4612 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4613 mountingblockpiecedownyvertex[i]);
4614 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4615 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4616 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
4617 mountingblockpiecedownshape[i],fSSDSupportRingAl);
4618 mountingblockpiecedown[i]->SetLineColor(fColorG10);
4619 ///////////////////////////
4620 // Mounting Block Up Vertex
4621 ///////////////////////////
4622 mountingblockpieceupshape[i] = new TGeoXtru(2);
4623 sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4624 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4625 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4626 + fgkMountingBlockSupportUpHeight[i];
4627 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4628 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4629 + fgkSSDMountingBlockHeight[1]
4630 - 0.5*fgkCoolingTubeSupportHeight
4631 - fgkSSDModuleCoolingBlockToSensor;
4632 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4633 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4634 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4635 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4636 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4637 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4638 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4639 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4640 + fgkSSDMountingBlockHeight[2]
4641 - fgkSSDMountingBlockHeight[0];
4642 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4643 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4644 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4645 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4646 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4647 mountingblockpieceupyvertex[i]);
4648 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4649 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4650 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
4651 mountingblockpieceupshape[i],fSSDSupportRingAl);
4652 mountingblockpieceup[i]->SetLineColor(fColorG10);
4653 }
4654 ///////////////////////////////////////////////////////////////////
4655 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4656 ///////////////////////////////////////////////////////////////////
4657 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4658 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4659 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4660 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4661 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4662 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4663 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4664 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4665 char mountingblocksupportrapezoidowname[40];
4666 char mountingblocksupportrapezoidupname[40];
4667 Double_t scalefactor = 3./4.;
4668 for(Int_t i=0; i<fgklayernumber; i++){
4669 ////////////////////////////////////////////
4670 // Mounting Block Support Down Trapezoid Vertex
4671 ////////////////////////////////////////////
4672 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4673 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4674 - mountingsupportedge[i];
4675 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4676 mountingblocksupportrapezoidownxvertex[i][1] =
4677 mountingblocksupportrapezoidownxvertex[i][0];
4678 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4679 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4680 - mountingblockpiecedownyvertex[i][0]);
4681 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4682 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4683 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4684 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4685 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4686 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4687 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4688 mountingblocksupportrapezoidownyvertex[i]);
4689 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4690 -fgkMountingBlockSupportWidth[0]);
4691 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4692 sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4693 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
4694 mountingblocksupportrapezoidownshape[i],fSSDMountingBlockMedium);
4695 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4696 ////////////////////////////////////////////
4697 // Mounting Block Support Up Trapezoid Vertex
4698 ////////////////////////////////////////////
4699 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4700 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4701 - mountingsupportedge[i];
4702 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4703 mountingblocksupportrapezoidupxvertex[i][1] =
4704 mountingblocksupportrapezoidupxvertex[i][0];
4705 mountingblocksupportrapezoidupyvertex[i][1] =
4706 mountingblockpieceupyvertex[i][0]
4707 + scalefactor*(mountingblockpieceupyvertex[i][1]
4708 - mountingblockpieceupyvertex[i][0]);
4709 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4710 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4711 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4712 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4713 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4714 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4715 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4716 mountingblocksupportrapezoidupyvertex[i]);
4717 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4718 -fgkMountingBlockSupportWidth[0]);
4719 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4720 sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4721 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
4722 mountingblocksupportrapezoidupshape[i],fSSDMountingBlockMedium);
4723 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4724 }
4725 ///////////////////////////////////////////////////////////////////
4726 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4727 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4728 Double_t boxoriginup[fgklayernumber][2][3];
4729 Double_t boxorigindown[fgklayernumber][2][3];
4730 char mountingblocksupportboxdownname[34];
4731 char mountingblocksupportboxupname[34];
4732 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4733 mountingblocksupportrot->SetAngles(90.,180.,-90);
4734 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4735 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4736 TGeoHMatrix* laddersupportmatrix[2];
4737 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4738 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4739 /////////////////////////////////////////////////////////////
4740 // Creating Mother Volume for Containment
4741 /////////////////////////////////////////////////////////////
4742 Double_t *xmothervertex[fgklayernumber];
4743 Double_t *ymothervertex[fgklayernumber];
4744 for(Int_t i=0; i<fgklayernumber; i++){
4745 xmothervertex[i] = new Double_t[8];
4746 ymothervertex[i] = new Double_t[8];
4747 }
4748 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4749 TGeoVolume* downmotherladdersupport[fgklayernumber];
4750 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4751 TGeoVolume* upmotherladdersupport[fgklayernumber];
4752 char upmotheladdersupportname[30];
4753 char downmotheladdersupportname[30];
4754 for(Int_t i=0; i<fgklayernumber; i++){
4755 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4756 - mountingsupportedge[i];
4757 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4758 xmothervertex[i][1] = xmothervertex[i][0];
4759 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4760 + fgkMountingBlockSupportWidth[0];
4761 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4762 ymothervertex[i][2] = ymothervertex[i][1];
4763 xmothervertex[i][3] = xmothervertex[i][2];
4764 ymothervertex[i][3] = -ymothervertex[i][0];
4765 xmothervertex[i][4] = -xmothervertex[i][0];
4766 ymothervertex[i][4] = ymothervertex[i][3];
4767 xmothervertex[i][5] = xmothervertex[i][4];
4768 ymothervertex[i][5] = -ymothervertex[i][1];
4769 xmothervertex[i][6] = -xmothervertex[i][2];
4770 ymothervertex[i][6] = ymothervertex[i][5];
4771 xmothervertex[i][7] = xmothervertex[i][6];
4772 ymothervertex[i][7] = ymothervertex[i][0];
4773 sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4774 sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
4775 downmotherladdersupportshape[i] = new TGeoXtru(2);
4776 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4777 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4778 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4779 + fgkMountingBlockSupportDownHeight
4780 + fgkSSDMountingBlockHeight[1]
4781 - 0.5*fgkCoolingTubeSupportHeight
4782 - fgkSSDModuleCoolingBlockToSensor);
4783 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4784 downmotherladdersupportshape[i],fSSDAir);
4785 upmotherladdersupportshape[i] = new TGeoXtru(2);
4786 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4787 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4788 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4789 + fgkMountingBlockSupportUpHeight[i]
4790 + fgkSSDMountingBlockHeight[1]
4791 - 0.5*fgkCoolingTubeSupportHeight
4792 - fgkSSDModuleCoolingBlockToSensor);
4793 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4794 upmotherladdersupportshape[i],fSSDAir);
4795 }
4796 for(Int_t i=0; i<fgklayernumber; i++){
4797 /////////////////////////
4798 // Setting the box origin
4799 /////////////////////////
4800 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4801 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
4802 + 0.5*fgkMountingBlockSupportDownHeight;
4803 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4804 - 0.5*fgkMountingBlockSupportWidth[0];
4805
4806 boxorigindown[i][1][0] = 0.0;
4807 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4808 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4809 - fgkMountingBlockSupportWidth[0]);
4810
4811 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4812 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4813 + 0.5*fgkMountingBlockSupportUpHeight[i];
4814 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4815 - 0.5*fgkMountingBlockSupportWidth[0];
4816
4817 boxoriginup[i][1][0] = 0.0;
4818 boxoriginup[i][1][1] = fgkMountingBlockSupportRadius[i]
4819 + 0.5*fgkMountingBlockSupportUpHeight[i];
4820 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4821 - fgkMountingBlockSupportWidth[0]);
4822
4823 /////////////////////////
4824 // Setting the boxes
4825 /////////////////////////
4826 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4827 + fgkSSDMountingBlockLength[0]),
4828 0.5*fgkMountingBlockSupportDownHeight,
4829 0.5*fgkMountingBlockSupportWidth[0],
4830 boxorigindown[i][0]);
4831 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4832 0.5*fgkMountingBlockSupportDownHeight,
4833 0.5*(fgkMountingBlockSupportWidth[1]
4834 - fgkMountingBlockSupportWidth[0]),
4835 boxorigindown[i][1]);
4836
4837 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4838 + fgkSSDMountingBlockLength[0]),
4839 0.5*fgkMountingBlockSupportUpHeight[i],
4840 0.5*fgkMountingBlockSupportWidth[0],
4841 boxoriginup[i][0]);
4842
4843 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4844 0.5*fgkMountingBlockSupportUpHeight[i],
4845 0.5*(fgkMountingBlockSupportWidth[1]
4846 - fgkMountingBlockSupportWidth[0]),
4847 boxoriginup[i][1]);
4848 ///////////////////////////////////////
4849 // Adding the Volumes to Mother Volume
4850 ///////////////////////////////////////
4851 for(Int_t j=0; j<2; j++){
4852 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4853 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4854 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4855 mountingblocksupportboxdownshape[i][j],
4856 fSSDMountingBlockMedium);
4857 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4858 mountingblocksupportboxupshape[i][j],
4859 fSSDMountingBlockMedium);
4860 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4861 mountingblocksupportboxup[i][j]->SetLineColor(9);
4862 for(Int_t k=0; k<2; k++){
4863 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4864 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4865 }
4866 }
4867 for(Int_t k=0; k<2; k++){
4868 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4869 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4870 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4871 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4872 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4873 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4874 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4875 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4876 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4877 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4878 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4879 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
4880 }
4881 }
4882 TList* laddersupportlist = new TList();
4883 laddersupportlist->Add(downmotherladdersupport[0]);
4884 laddersupportlist->Add(upmotherladdersupport[0]);
4885 laddersupportlist->Add(downmotherladdersupport[1]);
4886 laddersupportlist->Add(upmotherladdersupport[1]);
4887 /////////////////////////////////////////////////////////////
4888 // Deallocating memory
4889 /////////////////////////////////////////////////////////////
4890 for(Int_t i=0; i<fgklayernumber; i++){
4891 for(Int_t j=0; j<nedges+1; j++)
4892 delete vertex[i][j];
4893 delete mountingsupportedgevector[i];
4894 delete [] vertex[i];
4895 delete vertexlist[i];
4896 delete [] xsidevertex[i];
4897 delete [] ysidevertex[i];
4898 delete [] xcentervertex[i];
4899 delete [] ycentervertex[i];
4900 delete [] xsidelowervertex[i];
4901 delete [] ysidelowervertex[i];
4902 delete [] xcenterlowervertex[i];
4903 delete [] ycenterlowervertex[i];
4904 }
4905 delete xsidevertex;
4906 delete ysidevertex;
4907 delete xcentervertex;
4908 delete ycentervertex;
4909 delete xsidelowervertex;
4910 delete ysidelowervertex;
4911 delete xcenterlowervertex;
4912 delete ycenterlowervertex;
4913 delete globalrefladdersupportrot;
4914 delete mountingblocksupportrot;
4915 /////////////////////
4916 return laddersupportlist;
4917}
4918 ////////////////////////////////////////////////////////////////////////////////
4919void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4920//////////////////////////////////////////
4921// Method Generating Ladder Support Ring
4922//////////////////////////////////////////
4923 if(!fCreateMaterials) CreateMaterials();
4924 if(!fTransformationMatrices) CreateTransformationMatrices();
4925 if(!fBasicObjects) CreateBasicObjects();
4926 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4927 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4928 const Int_t kssdlayladdernumber[fgklayernumber] =
4929 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4930 Double_t mountingsupportedge[fgklayernumber];
4931 Double_t mountingblockratio[fgklayernumber];
4932 Double_t theta[fgklayernumber];
4933 Double_t phi[fgklayernumber];
4934 for(Int_t i=0; i<fgklayernumber; i++){
4935 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4936 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4937 *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4938 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4939 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4940 / kssdlayladdernumber[i])));
4941 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4942 / fgkMountingBlockSupportRadius[i]);
4943 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4944 }
4945 TGeoRotation* globalrot = new TGeoRotation();
4946 globalrot->SetAngles(0.,-90.,0.);
4947 TGeoRotation** laddersupportrot[fgklayernumber];
4948 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4949 for(Int_t i=0; i<fgklayernumber; i++){
4950 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4951 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4952 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4953 laddersupportrot[i][j] = new TGeoRotation();
4954 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4955 switch(i){
4956 case 0: //Ladder of Layer5
4957 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4958 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4959 laddersupportmatrix[i][j]);
4960 break;
4961 case 1: //Ladder of Layer6
4962 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4963 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4964 laddersupportmatrix[i][j]);
4965 break;
4966 }
4967 }
4968 }
4969 /////////////////////////////////////////////////////////////
4970 // Creating Lower Ladder Support
4971 /////////////////////////////////////////////////////////////
4972 TVector3** ringsupportvertex[fgklayernumber];
4973 Double_t angle = 360./nedges;
4974 for(Int_t i=0; i<fgklayernumber; i++){
4975 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4976 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4977 * TMath::Cos(theta[i]));
4978 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4979 - mountingsupportedge[i],
4980 ringsupportvertex[i][0]->Y());
4981 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4982 ringsupportvertex[i][1]->Y());
4983 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4984 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4985 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4986 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4987 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4988 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4989 }
4990 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4991 for(Int_t j=0; j<nedges+1; j++){
4992 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
4993 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*CosD(90.0-j*angle),
4994 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*SinD(90.0-j*angle));
4995 }
4996 }
4997 Double_t **xmothervertex = new Double_t*[fgklayernumber];
4998 Double_t **ymothervertex = new Double_t*[fgklayernumber];
4999 for(Int_t i=0; i<fgklayernumber; i++){
5000 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5001 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5002 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
5003 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
5004 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
5005 }
5006 }
5007 char lowerladdersupportname[30];
5008 TGeoXtru* lowerladdersupportshape[fgklayernumber];
5009 TGeoVolume* lowerladdersupport[fgklayernumber];
5010 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5011 lowerladdersupportrot->SetAngles(90.,180.,-90);
5012 for(Int_t i=0; i<fgklayernumber; i++){
5013 lowerladdersupportshape[i] = new TGeoXtru(2);
5014 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
5015 xmothervertex[i],ymothervertex[i]);
5016 lowerladdersupportshape[i]->DefineSection(0,0.);
5017 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
5018 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
5019 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
5020 lowerladdersupportshape[i],fSSDSupportRingAl);
5021 lowerladdersupport[i]->SetLineColor(fColorAl);
5022 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
5023 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
5024 }
5025 /////////////////////////////////////////////////////////////
5026 // Deallocating memory
5027 /////////////////////////////////////////////////////////////
5028 for(Int_t i=0; i<fgklayernumber; i++){
5029 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
5030 delete ringsupportvertex[i][j];
5031 delete [] ringsupportvertex[i];
5032 }
5033 for(Int_t i=0; i<fgklayernumber; i++){
5034 delete [] xmothervertex[i];
5035 delete [] ymothervertex[i];
5036 }
5037 delete xmothervertex;
5038 delete ymothervertex;
5039 delete globalrot;
5040 for(Int_t i=0; i<fgklayernumber; i++){
5041 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
5042 delete laddersupportrot[i][j];
5043 delete [] laddersupportrot[i];
5044 }
5045 }
5046 ////////////////////////////////////////////////////////////////////////////////
5047 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
5048 /////////////////////////////////////////////////////////////
5049 // Method generating Endcap CoverPlate
5050 /////////////////////////////////////////////////////////////
5051 // Holes Definition
5052 ///////////////////
5053 Int_t nendcapcoverplateholedges = 30;
5054 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
5055 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
5056 0.5*fgkEndCapCoverPlateThickness};
5057 TGeoXtru* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
5058 nendcapcoverplateholedges,holesection);
5059 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
5060 endcapcoverplatesmallholeshape,fSSDAir);
5061 endcapcoverplatesmallhole->SetLineColor(6);
5062 TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
5063 nendcapcoverplateholedges,holesection);
5064 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
5065 endcapcoverplatebigholeshape,fSSDAir);
5066 endcapcoverplatebighole->SetLineColor(6);
5067 //////////////////////////
5068 // Screw Piece Definition
5069 //////////////////////////
5070 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
5071 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
5072 CosD(0.5*smallscrewangle),
5073 0.5*fgkEndCapCoverPlateThickness);
5074 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
5075 endcapsmallscrewpieceshape,
5076 fSSDCoolingTubePhynox);
5077 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
5078 ///////////////////
5079 // Box Definition
5080 ///////////////////
5081 TGeoBBox* endcapcoverplateboxshape[4];
5082 TGeoVolume* endcapcoverplatebox[4];
5083 Double_t boxorigin[5][3];
5084 boxorigin[0][0] = 0.;
5085 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
5086 boxorigin[0][2] = 0.;
5087
5088 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
5089 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
5090 boxorigin[1][2] = 0.;
5091
5092 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
5093 + fgkEndCapCoverPlateSmallHoleSeparation[1];
5094 boxorigin[2][1] = boxorigin[1][1];
5095 boxorigin[2][2] = 0.;
5096
5097 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
5098 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
5099 boxorigin[3][1] = boxorigin[1][1];
5100 boxorigin[3][2] = 0.;
5101
5102 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5103 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5104 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
5105 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5106
5107 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5108 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5109 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5110 + fgkEndCapCoverPlateSmallHoleRadius,
5111 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5112
5113 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5114 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5115 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5116 + fgkEndCapCoverPlateSmallHoleRadius,
5117 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5118
5119 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5120 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5121 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5122 + fgkEndCapCoverPlateSmallHoleRadius,
5123 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5124
5125 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
5126 fSSDAir);
5127 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
5128 fSSDAir);
5129 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
5130 fSSDAir);
5131 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
5132 fSSDAir);
5133 endcapcoverplatebox[0]->SetLineColor(6);
5134 endcapcoverplatebox[1]->SetLineColor(6);
5135 endcapcoverplatebox[2]->SetLineColor(6);
5136 endcapcoverplatebox[3]->SetLineColor(6);
5137 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5138 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5139 fgkEndCapCoverPlateSmallHoleRadius,
5140 0.5*fgkEndCapCoverPlateThickness,
5141 endcapfillingboxorigin);
5142 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
5143 fSSDAir);
5144 endcapfillingbox->SetLineColor(6);
5145 ////////////////////////////
5146 // Contour Xtru Definition
5147 ////////////////////////////
5148 const Int_t kcontourvertexnumber = 10;
5149 Double_t xcontourvertex[kcontourvertexnumber];
5150 Double_t ycontourvertex[kcontourvertexnumber];
5151 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5152 xcontourvertex[1] = xcontourvertex[0];
5153 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5154 xcontourvertex[3] = xcontourvertex[2];
5155 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5156 xcontourvertex[5] = xcontourvertex[4];
5157 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5158 xcontourvertex[7] = xcontourvertex[6];
5159 xcontourvertex[8] = xcontourvertex[4];
5160 xcontourvertex[9] = xcontourvertex[8];
5161 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5162 - (kendcapcoverplatesmallholenumber[1]-1)
5163 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5164 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5165 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5166 ycontourvertex[2] = ycontourvertex[1];
5167 ycontourvertex[3] = ycontourvertex[0];
5168 ycontourvertex[4] = ycontourvertex[3];
5169 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5170 ycontourvertex[6] = ycontourvertex[5];
5171 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5172 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5173 + fgkEndCapCoverPlateSmallHoleRadius;
5174 ycontourvertex[8] = ycontourvertex[7];
5175 ycontourvertex[9] = ycontourvertex[0];
5176 TGeoXtru* contourshape = new TGeoXtru(2);
5177 contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex);
5178 contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5179 contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5180 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,fSSDAir);
5181 contour->SetLineColor(6);
5182 /////////////////////////////
5183 // Hole Contour Xtru Definition
5184 ////////////////////////////
5185 const Int_t kholecontourvertexnumber = 10;
5186 Double_t xholecontourvertex[2][kcontourvertexnumber];
5187 Double_t yholecontourvertex[2][kcontourvertexnumber];
5188 xholecontourvertex[0][0] = xcontourvertex[0];
5189 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5190 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5191 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5192 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5193 + 0.5*(fgkEndCapCoverPlateLength[2]
5194 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5195 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5196 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5197 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5198 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5199 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5200 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5201
5202 yholecontourvertex[0][0] = ycontourvertex[1];
5203 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5204 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5205 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5206 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5207 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5208 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5209 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5210 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5211 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5212 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5213
5214 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5215 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5216 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5217 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5218 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5219 + 0.5*(fgkEndCapCoverPlateLength[2]
5220 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5221 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5222 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5223 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5224 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5225 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5226 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5227
5228 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5229 - fgkEndCapCoverPlateWidth[0]);
5230 yholecontourvertex[1][1] = ycontourvertex[0];
5231 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5232 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5233 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5234 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5235 - fgkEndCapCoverPlateWidth[0]
5236 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5237 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5238 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5239 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5240 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5241
5242 TGeoXtru* holecontourshape[2];
5243 holecontourshape[0] = new TGeoXtru(2);
5244 holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0],
5245 yholecontourvertex[0]);
5246 holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5247 holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5248
5249 holecontourshape[1] = new TGeoXtru(2);
5250 holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1],
5251 yholecontourvertex[1]);
5252 holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5253 holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5254
5255 TGeoVolume* holecontour[2];
5256 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0],fSSDAir);
5257 holecontour[0]->SetLineColor(6);
5258 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1],fSSDAir);
5259 holecontour[1]->SetLineColor(6);
5260 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5261 + fgkEndCapCoverPlateLength[2],0.,0.);
5262 TGeoTranslation* bigholetrans[3];
5263 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5264 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5265 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5266 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5267 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5268 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5269 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5270 /////////////////////////////////
5271 // Mother Volume Xtru Definition
5272 /////////////////////////////////
5273 const Int_t kmothervertexnumber = 12;
5274 Double_t xmothervertex[kmothervertexnumber];
5275 Double_t ymothervertex[kmothervertexnumber];
5276 xmothervertex[0] = xcontourvertex[0];
5277 xmothervertex[1] = xmothervertex[0];
5278 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5279 xmothervertex[3] = xmothervertex[2];
5280 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5281 xmothervertex[5] = xmothervertex[4];
5282 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5283 xmothervertex[7] = xmothervertex[6];
5284 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5285 + fgkEndCapCoverPlateLength[2];
5286 xmothervertex[9] = xmothervertex[8];
5287 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5288 xmothervertex[11] = xmothervertex[10];
5289
5290 ymothervertex[0] = ycontourvertex[0];
5291 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5292 ymothervertex[2] = ymothervertex[1];
5293 ymothervertex[3] = ycontourvertex[1];
5294 ymothervertex[4] = ymothervertex[3];
5295 ymothervertex[5] = ymothervertex[1];
5296 ymothervertex[6] = ymothervertex[5];
5297 ymothervertex[7] = ymothervertex[0];
5298 ymothervertex[8] = ymothervertex[7];
5299 ymothervertex[9] = ymothervertex[8]
5300 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5301 ymothervertex[10] = ymothervertex[9];
5302 ymothervertex[11] = ymothervertex[8];
5303 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5304 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5305 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5306 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5307 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5308 ////////////////////////////////////////
5309 // Adding Nodes
5310 ////////////////////////////////////////
5311// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5312 TGeoTranslation*** endcapcoverplatesmallholetrans;
5313 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5314 Double_t transx[4] = {0,
5315 fgkEndCapCoverPlateSmallHoleSeparation[0],
5316 fgkEndCapCoverPlateSmallHoleSeparation[0]
5317 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5318 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5319 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5320 Int_t index = 0;
5321 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5322 endcapcoverplatesmallholetrans[i] =
5323 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5324 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5325 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5326 endcapcoverplatesmallholetrans[i][j] =
5327 new TGeoTranslation(transx[i],
5328 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5329 if(index!=10){
5330 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5331 index,endcapcoverplatesmallholetrans[i][j]);
5332 mothercoverplate->AddNode(endcapsmallscrewpiece,
5333 index,endcapcoverplatesmallholetrans[i][j]);
5334 }
5335 if(j<kendcapcoverplatesmallholenumber[1]-1)
5336 mothercoverplate->AddNode(endcapcoverplatebox[0],
5337 index,endcapcoverplatesmallholetrans[i][j]);
5338 }
5339 }
5340 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5341 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5342 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5343 mothercoverplate->AddNode(endcapfillingbox,1);
5344 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5345 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5346 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5347 mothercoverplate->AddNode(holecontour[0],1);
5348 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5349 mothercoverplate->AddNode(holecontour[1],1);
5350 mothercoverplate->AddNode(contour,1);
5351 /////////////////////////////////
5352 return mothercoverplate;
5353 }
5354 ////////////////////////////////////////////////////////////////////////////////
5355 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5356 /////////////////////////////////////////////////////////////
5357 // Getting EndCap Cooling Tube
5358 /////////////////////////////////////////////////////////////
5359 TGeoTorus* endcapcoolingtubetorushape[5];
5360 TGeoVolume* endcapcoolingtubetorus[5];
5361 TGeoTube* endcapcoolingtubeshape[4];
5362 TGeoVolume* endcapcoolingtube[4];
5363 char endcapcoolingtubetorusname[30];
5364 char endcapcoolingtubename[30];
5365 TGeoTorus* endcapcoolingwatertubetorushape[5];
5366 TGeoVolume* endcapcoolingwatertubetorus[5];
5367 TGeoTube* endcapcoolingwatertubeshape[4];
5368 TGeoVolume* endcapcoolingwatertube[4];
5369 char endcapcoolingwatertubetorusname[30];
5370 char endcapcoolingwatertubename[30];
5371 for(Int_t i=0; i<5; i++){
5372 sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5373 sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5374 sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5375 sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5376 if(i==3){
5377 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5378 fgkEndCapCoolingTubeRadiusMin,
5379 fgkEndCapCoolingTubeRadiusMax,
5380 90.0,fgkEndCapCoolingTubeAngle[3]);
5381 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5382 0.,fgkEndCapCoolingTubeRadiusMin,
5383 90.0,fgkEndCapCoolingTubeAngle[3]);
5384 }
5385 else{
5386 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5387 :fgkEndCapCoolingTubeAxialRadius[1],
5388 fgkEndCapCoolingTubeRadiusMin,
5389 fgkEndCapCoolingTubeRadiusMax,
5390 0.,fgkEndCapCoolingTubeAngle[i]);
5391 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5392 :fgkEndCapCoolingTubeAxialRadius[1],
5393 0.,fgkEndCapCoolingTubeRadiusMin,
5394 0.,fgkEndCapCoolingTubeAngle[i]);
5395 }
5396 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5397 endcapcoolingtubetorushape[i],
5398 fSSDCoolingTubePhynox);
5399 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5400 endcapcoolingwatertubetorushape[i],
5401 fSSDCoolingTubeWater);
5402 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5403 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5404 if(i<4){
5405 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5406 fgkEndCapCoolingTubeRadiusMax,
5407 0.5*fgkEndCapCoolingTubeLength[i]);
5408 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5409 0.5*fgkEndCapCoolingTubeLength[i]);
5410 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5411 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5412 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5413 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5414 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5415 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5416 }
5417 }
5418 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5419 /////////////////////////////////////////
5420 // Transformation for Volume Positioning
5421 /////////////////////////////////////////
5422 TGeoCombiTrans* coolingtubecombitrans[6];
5423 TGeoRotation* coolingtuberot[8];
5424 TGeoTranslation* coolingtubetrans[6];
5425 TGeoHMatrix* coolingtubematrix[4];
5426 TGeoCombiTrans* torustubecombitrans[4];
5427 TGeoRotation* torustuberot[7];
5428 TGeoTranslation* torustubetrans[4];
5429 TGeoHMatrix* torustubematrix[5];
5430 TGeoCombiTrans* coolingwatertubecombitrans[6];
5431 TGeoRotation* coolingwatertuberot[8];
5432 TGeoTranslation* coolingwatertubetrans[6];
5433 TGeoHMatrix* coolingwatertubematrix[4];
5434 TGeoCombiTrans* toruswatertubecombitrans[4];
5435 TGeoRotation* toruswatertuberot[7];
5436 TGeoTranslation* toruswatertubetrans[4];
5437 TGeoHMatrix* toruswatertubematrix[5];
5438 for(Int_t i=0; i<8; i++){
5439 if(i<6){
5440 coolingtubetrans[i] = new TGeoTranslation();
5441 coolingwatertubetrans[i] = new TGeoTranslation();
5442 }
5443 if(i<8){
5444 coolingtuberot[i] = new TGeoRotation();
5445 coolingwatertuberot[i] = new TGeoRotation();
5446 }
5447 if(i<4){
5448 torustubetrans[i] = new TGeoTranslation();
5449 toruswatertubetrans[i] = new TGeoTranslation();
5450 }
5451 if(i<7){
5452 torustuberot[i] = new TGeoRotation();
5453 toruswatertuberot[i] = new TGeoRotation();
5454 }
5455 }
5456 /////////////////////////////////////////
5457 // Transformation for Inox Volume Positioning
5458 /////////////////////////////////////////
5459 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5460 -endcapcoolingtubeshape[0]->GetDz(),0.);
5461 coolingtuberot[0]->SetAngles(0.,90.,0.);
5462 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5463 *coolingtuberot[0]);
5464
5465 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5466 coolingtuberot[1]->SetAngles(0.,90.,0.);
5467 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5468 *coolingtuberot[1]);
5469
5470 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5471 *CosD(fgkEndCapCoolingTubeAngle[0]),
5472 fgkEndCapCoolingTubeAxialRadius[0]
5473 *SinD(fgkEndCapCoolingTubeAngle[0]),
5474 0.);
5475 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5476 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5477 *coolingtuberot[2]);
5478
5479 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5480 * (*coolingtubecombitrans[1]));
5481
5482 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5483 endcapcoolingtubeshape[1]->GetDz());
5484 torustuberot[0]->SetAngles(0.,90.,0.);
5485 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5486
5487 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5488
5489 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5490 -endcapcoolingtubeshape[2]->GetDz(),0.);
5491 coolingtuberot[3]->SetAngles(0.,90.,0.);
5492 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5493 *coolingtuberot[3]);
5494 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5495 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5496 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5497
5498 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5499 endcapcoolingtubeshape[2]->GetDz());
5500 torustuberot[1]->SetAngles(0.,90.,0.);
5501 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5502 torustuberot[2]->SetAngles(180.,0.,0.);
5503 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5504 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5505
5506 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5507 -fgkEndCapCoolingTubeAxialRadius[0]);
5508 torustuberot[3]->SetAngles(0.,90.,0.);
5509 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5510 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5511 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5512 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5513
5514 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5515 fgkEndCapCoolingTubeAxialRadius[0],0.);
5516 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5517 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5518 *coolingtuberot[5]);
5519 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5520 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5521 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5522
5523 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5524 endcapcoolingtubeshape[0]->GetDz());
5525 torustuberot[5]->SetAngles(0.,90.,0.);
5526 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5527 torustuberot[6]->SetAngles(-90.,0.,0.);
5528 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5529 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5530
5531 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5532 endcapcoolingtubeshape[3]->GetDz(),0.);
5533 coolingtuberot[6]->SetAngles(0.,90.,0.);
5534 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5535 *coolingtuberot[6]);
5536 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5537 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5538 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5539 /////////////////////////////////////////
5540 // Transformation for Water Volume Positioning
5541 /////////////////////////////////////////
5542 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5543 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5544 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5545 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5546 *coolingwatertuberot[0]);
5547
5548 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5549 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5550 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5551 *coolingwatertuberot[1]);
5552
5553 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5554 *CosD(fgkEndCapCoolingTubeAngle[0]),
5555 fgkEndCapCoolingTubeAxialRadius[0]
5556 *SinD(fgkEndCapCoolingTubeAngle[0]),
5557 0.);
5558 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5559 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5560 *coolingwatertuberot[2]);
5561
5562 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5563 * (*coolingwatertubecombitrans[1]));
5564
5565 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5566 endcapcoolingwatertubeshape[1]->GetDz());
5567 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5568 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5569 *toruswatertuberot[0]);
5570
5571 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5572 * (*toruswatertubecombitrans[0]));
5573
5574 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5575 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5576 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5577 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5578 *coolingwatertuberot[3]);
5579 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5580 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5581 * (*coolingwatertubecombitrans[3]));
5582 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5583
5584 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5585 endcapcoolingwatertubeshape[2]->GetDz());
5586 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5587 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5588 *toruswatertuberot[1]);
5589 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5590 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5591 * (*toruswatertubecombitrans[1]));
5592 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5593
5594 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5595 -fgkEndCapCoolingTubeAxialRadius[0]);
5596 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5597 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5598 *toruswatertuberot[3]);
5599 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5600 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5601 * (*toruswatertubecombitrans[2]));
5602 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5603
5604 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5605 fgkEndCapCoolingTubeAxialRadius[0],0.);
5606 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5607 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5608 *coolingwatertuberot[5]);
5609 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5610 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5611 * (*coolingwatertubecombitrans[4]));
5612 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5613
5614 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5615 endcapcoolingwatertubeshape[0]->GetDz());
5616 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5617 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5618 *toruswatertuberot[5]);
5619 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5620 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5621 * (*toruswatertubecombitrans[3]));
5622 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5623
5624 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5625 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5626 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5627 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5628 *coolingwatertuberot[6]);
5629 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5630 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5631 * (*coolingwatertubecombitrans[5]));
5632 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5633 /////////////////////////////////////////
5634 // Positioning Volumes
5635 /////////////////////////////////////////
5636 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5637 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5638
5639 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5640 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5641
5642 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5643 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5644
5645 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5646 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5647
5648 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5649 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5650
5651 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5652 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5653
5654 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5655 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5656
5657 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5658 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5659
5660 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5661 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5662
5663 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5664 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5665 /////////////////////////////////////////////////////////////
5666 // Deallocating memory
5667 /////////////////////////////////////////////////////////////
5668 for(Int_t i=0; i<8; i++){
5669 if(i<6){
5670 delete coolingtubetrans[i];
5671 delete coolingwatertubetrans[i];
5672 if(i!=0){
5673 delete coolingtubecombitrans[i];
5674 delete coolingwatertubecombitrans[i];
5675 }
5676 }
5677 if(i<8){
5678 delete coolingtuberot[i];
5679 delete coolingwatertuberot[i];
5680 }
5681 if(i<4){
5682 delete torustubetrans[i];
5683 delete toruswatertubetrans[i];
5684 delete torustubecombitrans[i];
5685 delete toruswatertubecombitrans[i];
5686 }
5687 if(i<7){
5688 delete torustuberot[i];
5689 delete toruswatertuberot[i];
5690 }
5691 }
5692 /////////////////////////////////////////////////////////////
5693 return endcapcoolingtubemother;
5694 }
5695 ////////////////////////////////////////////////////////////////////////////////
5696 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5697 /////////////////////////////////////////////////////////////
5698 // Getting EndCap Cover Side
5699 /////////////////////////////////////////////////////////////
5700 const Int_t kendcapcoverholenumber[2] = {7,5};
5701 const Int_t kvertexnumber = 15;
5702 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5703 xvertex[0] = 0.0;
5704 xvertex[1] = xvertex[0];
5705 xvertex[2] = fgkEndCapSideCoverLength[0];
5706 xvertex[3] = fgkEndCapSideCoverLength[1];
5707 xvertex[4] = xvertex[3];
5708 xvertex[5] = fgkEndCapSideCoverLength[2];
5709 xvertex[6] = xvertex[5];
5710 xvertex[7] = xvertex[2];
5711 xvertex[8] = xvertex[7];
5712 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5713 xvertex[10] = xvertex[9];
5714 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5715 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5716 * fgkEndCapSideCoverLength[4];
5717 xvertex[12] = xvertex[11];
5718 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5719 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5720 * fgkEndCapSideCoverLength[4];
5721 xvertex[14] = xvertex[13];
5722 yvertex[0] = 0.0;
5723 yvertex[1] = fgkEndCapSideCoverWidth[0];
5724 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5725 yvertex[3] = yvertex[2];
5726 yvertex[4] = fgkEndCapSideCoverWidth[1];
5727 yvertex[5] = yvertex[4];
5728 yvertex[6] = yvertex[0];
5729 yvertex[7] = yvertex[6];
5730 yvertex[8] = fgkEndCapSideCoverWidth[6];
5731 yvertex[9] = yvertex[8];
5732 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5733 yvertex[11] = yvertex[10];
5734 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5735 yvertex[13] = yvertex[12];
5736 yvertex[14] = yvertex[6];
5737 TGeoXtru* endcapsidecovershape = new TGeoXtru(2);
5738 endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex);
5739 endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5740 endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5741 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5742 endcapsidecovershape,fSSDCoolingTubePhynox);
5743 endcapsidecover->SetLineColor(fColorPhynox);
5744 ////////////////////////////////////////////
5745 // Defininition of Mother Volume
5746 ////////////////////////////////////////////
5747 const Int_t kmothervertexnumber = 7;
5748 Double_t xmothervertex[kmothervertexnumber];
5749 Double_t ymothervertex[kmothervertexnumber];
5750 for(Int_t i=0; i<kmothervertexnumber; i++){
5751 xmothervertex[i] = xvertex[i];
5752 ymothervertex[i] = yvertex[i];
5753 }
5754 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5755 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5756 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5757 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5758 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5759 endcapsidecovermothershape,fSSDAir);
5760 ////////////////////////////////////////////
5761 endcapsidecovermother->AddNode(endcapsidecover,1);
5762 TGeoBBox* endcapsidecoverboxshape[4];
5763 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5764 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5765 0.5*fgkEndCapSideCoverLength[4],
5766 0.5*fgkEndCapSideCoverThickness);
5767 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5768 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5769 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5770 - fgkEndCapSideCoverLength[4]),
5771 0.5*fgkEndCapSideCoverThickness);
5772 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5773 0.5*fgkEndCapSideCoverLength[4],
5774 0.5*fgkEndCapSideCoverThickness);
5775 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5776 0.5*fgkEndCapSideCoverWidth[5],
5777 0.5*fgkEndCapSideCoverThickness);
5778 TGeoVolume* endcapsidecoverbox[4];
5779 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5780 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5781 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5782 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5783 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5784// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5785 TGeoTranslation** endcapsidecoverboxtrans;
5786 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5787 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5788 + fgkEndCapSideCoverLength[0],
5789 endcapsidecoverboxshape[0]->GetDY()
5790 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5791 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5792 + xvertex[11],
5793 endcapsidecoverboxshape[1]->GetDY()
5794 + yvertex[12],0.);
5795 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5796 + xvertex[11],
5797 endcapsidecoverboxshape[2]->GetDY()
5798 + yvertex[12]
5799 + 2.*endcapsidecoverboxshape[1]->GetDY()
5800 + fgkEndCapSideCoverWidth[5],0.);
5801 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5802 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5803 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5804 for(Int_t i=0; i<2; i++)
5805 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5806 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5807 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5808 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5809 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5810 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5811 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5812 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5813 }
5814 for(Int_t i=0; i<2; i++)
5815 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5816 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5817 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5818 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5819 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5820 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5821 +fgkEndCapSideCoverLength[4]),0.0);
5822 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5823 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5824 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5825 +i*(kendcapcoverholenumber[1]-1)+j]);
5826 }
5827 return endcapsidecovermother;
5828 }
5829 ////////////////////////////////////////////////////////////////////////////////
5830 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5831 ////////////////////////////////////////////////////////////////////////////////
5832 // Method returning Interface Card A, Interface Card B, Supply Card
5833 ////////////////////////////////////////////////////////////////////////////////
5834 /////////////////////
5835 // Supply Card
5836 /////////////////////
5837 // Electronic Board Back Al Plane
5838 const Int_t kelectboardbackvertexnumber = 8;
5839 Double_t xelectboardback[kelectboardbackvertexnumber];
5840 Double_t yelectboardback[kelectboardbackvertexnumber];
5841 xelectboardback[0] = 0.0;
5842 xelectboardback[1] = xelectboardback[0];
5843 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5844 xelectboardback[3] = xelectboardback[2];
5845 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5846 xelectboardback[5] = xelectboardback[4];
5847 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5848 xelectboardback[7] = xelectboardback[6];
5849
5850 yelectboardback[0] = 0.0;
5851 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5852 yelectboardback[2] = yelectboardback[1];
5853 yelectboardback[3] = yelectboardback[0];
5854 yelectboardback[4] = yelectboardback[3];
5855 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5856 yelectboardback[6] = yelectboardback[5];
5857 yelectboardback[7] = yelectboardback[4];
5858 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5859 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5860 xelectboardback,yelectboardback);
5861 electboardbackshape->DefineSection(0,0.0);
5862 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5863 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5864 electboardbackshape,fSSDSupportRingAl);
5865 electboardback->SetLineColor(fColorAl);
5866 // Electronic Board Kapton Layer
5867 const Int_t kelectlayervertexnumber = 8;
5868 Double_t xelectlayer[kelectlayervertexnumber];
5869 Double_t yelectlayer[kelectlayervertexnumber];
5870 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5871 xelectlayer[1] = xelectlayer[0];
5872 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5873 xelectlayer[3] = xelectlayer[2];
5874 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5875
5876 yelectlayer[0] = 0.0;
5877 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5878 yelectlayer[2] = yelectlayer[1];
5879 yelectlayer[3] = yelectlayer[0];
5880 yelectlayer[4] = yelectlayer[3];
5881 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5882 yelectlayer[6] = yelectlayer[5];
5883 yelectlayer[7] = yelectlayer[4];
5884 TGeoXtru* electlayershape = new TGeoXtru(2);
5885 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5886 electlayershape->DefineSection(0,0.0);
5887 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5888 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5889 electlayershape,fSSDKaptonFlexMedium);
5890 electlayer->SetLineColor(fColorKapton);
5891 // JMD Connector Female
5892 const Int_t kjmdconnectorvertexnumber = 6;
5893 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5894 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5895 xjmdconnectorvertex[0] = 0.0;
5896 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5897 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5898 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5899 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5900 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5901
5902 yjmdconnectorvertex[0] = 0.0;
5903 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5904 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5905 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5906 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5907 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5908 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5909 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5910 yjmdconnectorvertex);
5911 jmdconnectorshape->DefineSection(0,0.0);
5912 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5913 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5914 jmdconnectorshape,fSSDMountingBlockMedium);
5915 jmdconnector->SetLineColor(fColorG10);
5916 // Top Cable Connector
5917 const Int_t kcableconnectorvertexnumber = 8;
5918 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5919 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5920 xconnectorvertex[0] = 0.0;
5921 xconnectorvertex[1] = xconnectorvertex[0];
5922 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5923 xconnectorvertex[3] = xconnectorvertex[2];
5924 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5925 - fgkEndCapCardCableConnectorLength[2];
5926 xconnectorvertex[5] = xconnectorvertex[4];
5927 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5928 xconnectorvertex[7] = xconnectorvertex[6];
5929
5930 yconnectorvertex[0] = 0.0;
5931 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5932 yconnectorvertex[2] = yconnectorvertex[1];
5933 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5934 yconnectorvertex[4] = yconnectorvertex[3];
5935 yconnectorvertex[5] = yconnectorvertex[1];
5936 yconnectorvertex[6] = yconnectorvertex[5];
5937 yconnectorvertex[7] = yconnectorvertex[0];
5938 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5939 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5940 yconnectorvertex);
5941 cableconnectorshape->DefineSection(0,0.0);
5942 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5943 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5944 cableconnectorshape,fSSDMountingBlockMedium);
5945 cableconnector->SetLineColor(fColorG10);
5946 // Strip Connection
5947 TGeoBBox* endcapstripconnectionshape =
5948 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5949 0.5*fgkEndCapStripConnectionThickness,
5950 0.5*fgkEndCapStripConnectionWidth);
5951 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5952 endcapstripconnectionshape,
5953 fSSDSupportRingAl);
5954 endcapstripconnection->SetLineColor(fColorAl);
5955 // Interface Card B
5956 const Int_t kcardBvertexnumber = 12;
5957 Double_t xcardBvertexnumber[kcardBvertexnumber];
5958 Double_t ycardBvertexnumber[kcardBvertexnumber];
5959
5960 xcardBvertexnumber[0] = 0.0;
5961 xcardBvertexnumber[1] = xcardBvertexnumber[0];
5962 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5963 xcardBvertexnumber[3] = xcardBvertexnumber[2];
5964 xcardBvertexnumber[4] = xcardBvertexnumber[1];
5965 xcardBvertexnumber[5] = xcardBvertexnumber[4];
5966 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5967 xcardBvertexnumber[7] = xcardBvertexnumber[6];
5968 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5969 xcardBvertexnumber[9] = xcardBvertexnumber[8];
5970 xcardBvertexnumber[10] = xcardBvertexnumber[7];
5971 xcardBvertexnumber[11] = xcardBvertexnumber[10];
5972
5973 ycardBvertexnumber[0] = 0.0;
5974 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
5975 ycardBvertexnumber[2] = ycardBvertexnumber[1];
5976 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5977 ycardBvertexnumber[4] = ycardBvertexnumber[3];
5978 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5979 ycardBvertexnumber[6] = ycardBvertexnumber[5];
5980 ycardBvertexnumber[7] = ycardBvertexnumber[4];
5981 ycardBvertexnumber[8] = ycardBvertexnumber[7];
5982 ycardBvertexnumber[9] = ycardBvertexnumber[1];
5983 ycardBvertexnumber[10] = ycardBvertexnumber[9];
5984 ycardBvertexnumber[11] = ycardBvertexnumber[0];
5985
5986 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5987 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5988 interfacecardBshape->DefineSection(0,0.);
5989 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5990 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5991 fSSDMountingBlockMedium);
5992 interfacecardB->SetLineColor(46);
5993 // Interface Card B Electronic Board
5994 const Int_t kelectboardcardBvertexnumber = 14;
5995 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5996 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5997
5998 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5999 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
6000 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
6001 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
6002 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
6003 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
6004 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6005 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
6006 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6007 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
6008 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6009 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6010 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6011 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6012
6013 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6014 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6015 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
6016 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6017 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
6018 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
6019 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
6020 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6021 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
6022 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6023 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6024 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6025 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6026 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6027
6028 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6029 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6030 xelectboardcardBvertex,yelectboardcardBvertex);
6031 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6032 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6033 + fgkEndCapInterfaceElectBoardCardBThickness);
6034 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6035 fSSDSupportRingAl);
6036 electboardcardB->SetLineColor(fColorAl);
6037 // Generating Stiffener 2
6038 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6039 0.5*fgkEndCapStiffenerThickness,
6040 0.5*fgkEndCapStiffenerLength);
6041 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6042 endcapstiffener->SetLineColor(fColorAl);
6043 // Generating Mother Interface Card B Container
6044 const Int_t kinterfacecardBmothervertexnumber = 10;
6045 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6046 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6047
6048 xinterfacecardBmothervertex[0] = 0.0;
6049 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6050 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6051 + fgkEndCapInterfaceCardBThickness;
6052 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6053 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6054 + fgkEndCapInterfaceElectBoardCardBThickness;
6055 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6056 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6057 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6058 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6059 + fgkEndCapCardJMDConnectorLength[0];
6060 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6061
6062 yinterfacecardBmothervertex[0] = 0.0;
6063 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6064 + fgkEndCapInterfaceCardBWidth[1]
6065 + fgkEndCapInterfaceCardBWidth[2];
6066 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6067 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6068 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6069 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6070 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6071 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6072 + fgkEndCapCardJMDConnectorWidth[0]
6073 + fgkEndCapCardJMDConnectorWidth[1];
6074 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6075 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6076 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6077 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6078 xinterfacecardBmothervertex,
6079 yinterfacecardBmothervertex);
6080 interfacecardBmothershape->DefineSection(0,-1.e-15);
6081 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6082 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6083 interfacecardBmothershape,fSSDAir);
6084 electboardcardB->SetLineColor(fColorAl);
6085 // Positioning Volumes Mother Interface Card B Container
6086 TGeoRotation* interfacecardBrot = new TGeoRotation();
6087 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6088 interfacecardBrot->SetAngles(90.,-90.,-90.);
6089 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6090 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6091 TGeoRotation* electboardcardBrot = new TGeoRotation();
6092 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6093 electboardcardBrot->SetAngles(90.,90.,-90.);
6094 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6095 TGeoCombiTrans* electboardcardBcombitrans =
6096 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6097 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6098 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6099 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6100 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6101 TGeoTranslation* jmdconnectorcardBtrans[3];
6102 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6103 for(Int_t i=0; i<3; i++){
6104 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6105 + fgkEndCapCardJMDConnectorLength[0],
6106 fgkEndCapCardElectBoardLayerWidth[1],
6107 0.5*fgkEndCapCardJMDConnectorThickness
6108 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6109 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6110 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6111 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6112 *jmdconnectorcardBrot);
6113 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6114 }
6115 // Mother Supply Card Container
6116 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6117 // Interface Card Container
6118 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6119 // Placing Volumes in Mother Supply Card Container
6120 // JMD Connector Positioning
6121 TGeoTranslation* jmdconnectortrans[2];
6122 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6123 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6124 fgkEndCapCardElectBoardBackLength[0]
6125 - fgkEndCapCardJMDConnectorThickness
6126 - fgkEndCapCardJMDConnectorToLayer);
6127 TGeoRotation* jmdconnectorot = new TGeoRotation();
6128 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6129 + 2.*fgkEndCapCardJMDConnectorLength[0]
6130 + 2.*fgkEndCapCardElectBoardLayerThickness,
6131 fgkEndCapCardElectBoardLayerWidth[1],
6132 fgkEndCapCardJMDConnectorThickness
6133 + fgkEndCapCardJMDConnectorToLayer);
6134 jmdconnectorot->SetAngles(90.,180.,-90);
6135 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6136 * jmdconnectorot);
6137 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6138 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6139 // Top Cable Connector Placing
6140 TGeoRotation* cableconnectorot[2];
6141 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6142 TGeoTranslation* cableconnectortrans[3];
6143 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6144 cableconnectorot[0]->SetAngles(90.,0.,0.);
6145 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6146 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6147 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6148 *cableconnectorot[0]);
6149 TGeoHMatrix* cableconnectormatrix[2];
6150 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6151 new TGeoHMatrix((*cableconnectorot[1])
6152 *(*cableconnectorcombitrans));
6153 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6154 - fgkEndCapCardCableConnectorThickness,
6155 fgkEndCapCardCableConnectorLength[0]
6156 + fgkEndCapCardCableConnectorToLayer);
6157 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6158 - 2.*fgkEndCapCardCableConnectorThickness
6159 - fgkEndCapCardCableConnectorDistance,
6160 fgkEndCapCardCableConnectorLength[0]
6161 + fgkEndCapCardCableConnectorToLayer);
6162 for(Int_t i=0; i<2; i++){
6163 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6164 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6165 }
6166 TGeoRotation* electboardbackrot = new TGeoRotation();
6167 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6168 electboardbackrot->SetAngles(90.,-90.,-90.);
6169 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6170 + fgkEndCapCardJMDConnectorLength[0]
6171 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6172 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6173 *electboardbackrot);
6174 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6175 // Electronic Board Kapton Layer Positioning
6176 TGeoRotation* electlayerrot = new TGeoRotation();
6177 TGeoTranslation* electlayertrans[2];
6178 TGeoCombiTrans* electlayercombitrans[2];
6179 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6180 electlayerrot->SetAngles(90.,-90.,-90.);
6181 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6182 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6183 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6184 + 2.*fgkEndCapCardElectBoardLayerThickness
6185 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6186 for(Int_t i=0; i<2; i++){
6187 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6188 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6189 }
6190 // Placing Volumes in Mother Interface Card Container
6191 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6192 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6193 for(Int_t i=0; i<2; i++){
6194 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6195 }
6196 /////////////////////////////////////////////////////////////
6197 // Generation of Card Interface Container
6198 /////////////////////////////////////////////////////////////
6199 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6200 - fgkEndCapCardJMDConnectorLength[0]
6201 - fgkEndCapInterfaceCardBThickness
6202 - 9.*fgkEndCapStripConnectionThickness
6203 - 8.*fgkEndCapCardElectBoardBackThickness;
6204 const Int_t kcardinterfacecontainervertexnumber = 14;
6205 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6206 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6207 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6208 - 7.0*fgkEndCapStripConnectionThickness;
6209 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6210 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6211 + fgkEndCapStripConnectionThickness
6212 - fgkEndCapCardElectBoardLayerThickness
6213 - fgkEndCapCardCableConnectorWidth[0];
6214 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6215 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6216 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6217 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6218 + 2.0*fgkEndCapStripConnectionThickness;
6219 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6220 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6221 + fgkEndCapInterfaceCardBThickness;
6222 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6223 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6224 + fgkEndCapInterfaceElectBoardCardBThickness;
6225 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6226 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6227 - fgkEndCapInterfaceElectBoardCardBThickness
6228 + fgkEndCapCardJMDConnectorLength[0]
6229 + stiffenertransx+fgkEndCapStiffenerWidth;
6230 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6231
6232 ycardinterfacecontainervertex[0] = 0.;
6233 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6234 + fgkEndCapCardJMDConnectorWidth[0]
6235 + fgkEndCapCardJMDConnectorWidth[1];
6236 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6237 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6238 - fgkEndCapStripConnectionWidth;
6239 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6240 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6241 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6242 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6243 + fgkEndCapInterfaceCardBWidth[1]
6244 + fgkEndCapInterfaceCardBWidth[2];
6245 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6246 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6247 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6248 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6249 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6250 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6251
6252 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6253 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6254 xcardinterfacecontainervertex,
6255 ycardinterfacecontainervertex);
6256 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6257 - fgkEndCapCardElectBoardBackLength[0]));
6258 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6259 + fgkEndCapCardElectBoardBackLength[0]));
6260 TGeoVolume** cardinterfacecontainer;
6261 cardinterfacecontainer = new TGeoVolume*[4];
6262 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6263 interfacecardmothershape,fSSDAir);
6264 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6265 interfacecardmothershape,fSSDAir);
6266 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6267 interfacecardmothershape,fSSDAir);
6268 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6269 interfacecardmothershape,fSSDAir);
6270 /////////////////////////////////
6271 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6272 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6273 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6274 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6275 /////////////////////////////////
6276 TGeoRotation* endcapstripconnectionrot[2];
6277 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6278 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6279 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6280 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6281 * (*endcapstripconnectionrot[0]));
6282 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6283 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6284 -0.5*fgkEndCapCardElectBoardBackThickness,
6285 fgkEndCapCardElectBoardBackWidth[0]
6286 -endcapstripconnectionshape->GetDZ(),
6287 0.5*fgkEndCapCardElectBoardBackLength[0]);
6288 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6289 TGeoTranslation* cardinterfacetrans[9];
6290 TGeoHMatrix* cardinterfacematrix[9];
6291 for(Int_t i=0; i<7; i++){
6292 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6293 + fgkEndCapCardElectBoardBackThickness),
6294 0.0,0.0);
6295 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6296 * (*endcapstripconnectionmatrix));
6297 }
6298 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6299 + fgkEndCapCardElectBoardBackThickness),
6300 0.0,0.0);
6301 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6302 * (*endcapstripconnectionmatrix));
6303 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6304 + fgkEndCapCardElectBoardBackThickness),
6305 0.0,0.0);
6306 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6307 * (*endcapstripconnectionmatrix));
6308
6309 for(Int_t i=0; i<4; i++){
6310 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6311 cardinterfacematrix[7]);
6312 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6313 cardinterfacematrix[8]);
6314 }
6315 TGeoTranslation* mothersupplycardtrans =
6316 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6317 + 2.*fgkEndCapCardJMDConnectorLength[0]
6318 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6319 TGeoHMatrix* mothersupplycardmatrix[7];
6320 Int_t index[4] = {1,1,1,1};
6321 for(Int_t i=0; i<7; i++){
6322 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6323 * (*mothersupplycardtrans));
6324 for(Int_t j=0; j<4; j++){
6325 switch(j){
6326 case 0: //Layer5 EndCap Left Side
6327 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6328 cardinterfacematrix[i]);
6329 if(i!=0){
6330 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6331 mothersupplycardmatrix[i]);
6332 index[j]++;
6333
6334 }
6335 break;
6336 case 1: //Layer5 EndCap Rigth Side
6337 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6338 cardinterfacematrix[i]);
6339 if(i>0&&i<6){
6340 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6341 mothersupplycardmatrix[i]);
6342 index[j]++;
6343 }
6344 break;
6345 case 2: //Layer6 EndCap Left Side
6346 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6347 cardinterfacematrix[i]);
6348 if(i!=6){
6349 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6350 mothersupplycardmatrix[i]);
6351 index[j]++;
6352 }
6353 break;
6354 case 3: //Layer6 EndCap Right Side
6355 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6356 cardinterfacematrix[i]);
6357 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6358 mothersupplycardmatrix[i]);
6359 index[j]++;
6360 break;
6361 }
6362 }
6363 }
6364 // Positioning Interface
6365 TGeoTranslation* motherinterfacecardtrans =
6366 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6367 +0.5*fgkEndCapCardElectBoardBackThickness
6368 -fgkEndCapCardElectBoardLayerThickness
6369 +fgkEndCapStripConnectionThickness,0.,0.);
6370 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6371 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6372 // Positioning Interface Card B
6373 TGeoTranslation* interfacecardBmothertrans =
6374 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6375 + 2.*fgkEndCapStripConnectionThickness
6376 + fgkEndCapCardElectBoardBackThickness,0.,
6377 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6378 - fgkEndCapCardElectBoardBackLength[0]));
6379 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6380 interfacecardBmothertrans);
6381 // Positioning Stiffener
6382 TGeoTranslation* endcapstiffenertrans =
6383 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6384 + 2.0*fgkEndCapStripConnectionThickness
6385 + fgkEndCapInterfaceCardBThickness
6386 + fgkEndCapCardJMDConnectorLength[0]
6387 + stiffenertransx
6388 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6389 endcapstiffenershape->GetDZ()
6390 - 0.5*(fgkEndCapStiffenerLength
6391 - fgkEndCapCardElectBoardBackLength[0]));
6392 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6393 /////////////////////////////////////////////////////////////
6394 // Deallocating memory
6395 /////////////////////////////////////////////////////////////
6396 delete interfacecardBrot;
6397 delete interfacecardBtrans;
6398 delete electboardcardBtrans;
6399 delete electboardcardBrot;
6400 delete jmdconnectorcardBrot;
6401 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6402 delete jmdconnectorot;
6403 delete jmdconnectortrans[1];
6404 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6405 delete cableconnectorcombitrans;
6406 delete electboardbacktrans;
6407 delete electboardbackrot;
6408 delete electlayerrot;
6409 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6410 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6411 delete mothersupplycardtrans;
6412 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6413 /////////////////////////////////////////////////////////////
6414 return cardinterfacecontainer;
6415 }
6416 ////////////////////////////////////////////////////////////////////////////////
6417 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6418 /////////////////////////////////////////////////////////////
6419 // Method returning EndCap Mother Volume
6420 /////////////////////////////////////////////////////////////
6421 const Int_t kendcapcoverplatesmallholenumber = 9;
6422 Double_t endcapmotherorigin[3];
6423 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6424 + 0.5 *(fgkEndCapCoverPlateLength[3]
6425 + 2.0 * fgkEndCapCoverPlateLength[2]);
6426 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6427 - fgkEndCapCoverPlateWidth[2]
6428 - (kendcapcoverplatesmallholenumber-1)
6429 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6430 + 0.5*(fgkEndCapSideCoverLength[2]
6431 + fgkEndCapCoverPlateWidth[1]
6432 - fgkEndCapCoverPlateWidth[0])
6433 - (fgkEndCapCoverPlateWidth[1]
6434 - fgkEndCapCoverPlateWidth[0]);
6435 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6436 + 2.*fgkEndCapCoolingTubeRadiusMax
6437 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6438 + fgkEndCapSideCoverWidth[1]
6439 + fgkEndCapSideCoverThickness
6440 + fgkEndCapKaptonFoilThickness);
6441 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6442 + 2.0* fgkEndCapCoverPlateLength[2]
6443 + 2.0* fgkEndCapSideCoverThickness),
6444 0.5* (fgkEndCapSideCoverLength[2]
6445 + fgkEndCapCoverPlateWidth[1]
6446 - fgkEndCapCoverPlateWidth[0]),
6447 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6448 + fgkEndCapSideCoverWidth[1]
6449 + fgkEndCapSideCoverThickness
6450 + fgkEndCapKaptonFoilThickness),
6451 endcapmotherorigin);
6452 TGeoVolume** endcapassembly;
6453 endcapassembly = new TGeoVolume*[4];
6454 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6455 endcapmothershape,fSSDAir);
6456 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6457 endcapmothershape,fSSDAir);
6458 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6459 endcapmothershape,fSSDAir);
6460 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6461 endcapmothershape,fSSDAir);
6462 /////////////////////////////////
6463 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6464 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6465 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6466 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6467 /////////////////////////////////
6468 /////////////////////////////////////////////////////
6469 // Placing Endcap Cover Plate
6470 /////////////////////////////////////////////////////
6471 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6472 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6473 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6474 TGeoCombiTrans* endcapcoverplatecombitrans =
6475 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6476 endcapcoverplaterot);
6477 TGeoTranslation* endcapcoverplatetrans =
6478 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6479 TGeoHMatrix* endcapcoverplatematrix =
6480 new TGeoHMatrix((*endcapcoverplatetrans)
6481 * (*endcapcoverplatecombitrans));
6482 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6483 /////////////////////////////////////////////////////
6484 // Placing Endcap Side Cover
6485 /////////////////////////////////////////////////////
6486 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6487 TGeoRotation* endcapsidecoverot[2];
6488 TGeoCombiTrans* endcapsidecovercombitrans[3];
6489 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6490 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6491 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6492 - 0.5*(fgkEndCapCoverPlateWidth[0]
6493 - fgkEndCapCoverPlateWidth[2]
6494 - (kendcapcoverplatesmallholenumber-1)
6495 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6496 + 0.*fgkEndCapCoverPlateWidth[0]
6497 + fgkEndCapSideCoverLength[2],
6498 0.5*(fgkEndCapSideCoverThickness
6499 + fgkEndCapCoverPlateThickness)
6500 - 0.5*fgkEndCapCoverPlateThickness,
6501 endcapsidecoverot[0]);
6502 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6503 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6504 0.5*fgkEndCapCoverPlateThickness
6505 -fgkEndCapSideCoverWidth[1],
6506 endcapsidecoverot[1]);
6507 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6508 +fgkEndCapCoverPlateLength[3]
6509 +2.*fgkEndCapCoverPlateLength[2]
6510 +fgkEndCapSideCoverThickness,0.0,
6511 0.5*fgkEndCapCoverPlateThickness
6512 -fgkEndCapSideCoverWidth[1],
6513 endcapsidecoverot[1]);
6514 TGeoHMatrix* endcapsidecovermatrix[2];
6515 for(Int_t i=0; i<2; i++){
6516 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6517 * (*endcapsidecovercombitrans[0]));
6518 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6519 endcapsidecovermatrix[i]);
6520 }
6521 /////////////////////////////////////////////////////
6522 // Placing Endcap Cooling Tube
6523 /////////////////////////////////////////////////////
6524 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6525 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6526 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6527 TGeoCombiTrans* endcapccolingtubecombitrans
6528 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6529 + fgkEndCapCoolingTubeAxialRadius[1])
6530 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6531 - fgkEndCapCoolingTubeToCoverSide,
6532 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6533 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6534 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6535 endcapccolingtubecombitrans);
6536 /////////////////////////////////////////////////////
6537 // Placing Screws
6538 /////////////////////////////////////////////////////
6539 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6540 fgkEndCapCoverPlateScrewRadiusMin};
6541 Int_t screwcoverplatedgesnumber[2] = {20,20};
6542 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6543 fgkEndCapCoverPlateThickness
6544 + fgkEndCapCoolingTubeRadiusMax};
6545 TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6546 screwcoverplatedgesnumber,
6547 screwcoverplatesection);
6548 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6549 screwcoverplateshape,
6550 fSSDCoolingTubePhynox);
6551 screwcoverplate->SetLineColor(12);
6552 Double_t transx[4] = {0,
6553 fgkEndCapCoverPlateSmallHoleSeparation[0],
6554 fgkEndCapCoverPlateSmallHoleSeparation[0]
6555 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6556 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6557 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6558 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6559// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6560 TGeoTranslation*** endcapcoverplatescrewtrans;
6561 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6562 Int_t index = 0;
6563 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6564 endcapcoverplatescrewtrans[i] =
6565 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6566 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6567 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6568 if(index==1||index==9||index==28||index==36){
6569 endcapcoverplatescrewtrans[i][j] =
6570 new TGeoTranslation(transx[i],
6571 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6572 fgkEndCapSideCoverThickness);
6573 }
6574 else{
6575 endcapcoverplatescrewtrans[i][j] =
6576 new TGeoTranslation(transx[i],
6577 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6578 0.);
6579 }
6580 if(index!=19)
6581 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6582 endcapcoverplatescrewtrans[i][j]);
6583 }
6584 }
6585 /////////////////////////////////////////////////////
6586 // Placing Cover Plate Clips
6587 /////////////////////////////////////////////////////
6588 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6589 0.5*fgkEndCapCoverPlateClipWidth,
6590 0.5*fgkEndCapSideCoverThickness);
6591 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6592 endcapcoverplateclipshape,
6593 fSSDCoolingTubePhynox);
6594 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6595 0.5*fgkEndCapCoverPlateDownClipWidth,
6596 0.5*fgkEndCapSideCoverThickness);
6597 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6598 endcapcoverplatedownclipshape,
6599 fSSDCoolingTubePhynox);
6600 TGeoTranslation* endcapcoverplatecliptrans[4];
6601 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6602 - fgkEndCapCoverPlateLength[0]
6603 - fgkEndCapSideCoverThickness,
6604 0.0,
6605 0.5*(fgkEndCapSideCoverThickness
6606 + fgkEndCapCoverPlateThickness));
6607 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6608 - fgkEndCapCoverPlateLength[0]
6609 - fgkEndCapSideCoverThickness,
6610 (kendcapcoverplatescrewnumber[1]-1)
6611 * fgkEndCapSideCoverWidth[5],
6612 0.5*(fgkEndCapSideCoverThickness
6613 + fgkEndCapCoverPlateThickness));
6614 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6615 - fgkEndCapCoverPlateLength[0]
6616 + fgkEndCapCoverPlateLength[1]
6617 + 2.*fgkEndCapCoverPlateLength[0]
6618 - fgkEndCapCoverPlateClipLength
6619 + fgkEndCapSideCoverThickness,
6620 0.0,
6621 0.5*(fgkEndCapSideCoverThickness
6622 + fgkEndCapCoverPlateThickness));
6623 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6624 - fgkEndCapCoverPlateLength[0]
6625 + fgkEndCapCoverPlateLength[1]
6626 + 2.*fgkEndCapCoverPlateLength[0]
6627 - fgkEndCapCoverPlateClipLength
6628 + fgkEndCapSideCoverThickness,
6629 (kendcapcoverplatescrewnumber[1]-1)
6630 * fgkEndCapSideCoverWidth[5],
6631 0.5*(fgkEndCapSideCoverThickness
6632 + fgkEndCapCoverPlateThickness));
6633 endcapcoverplateclip->SetLineColor(fColorPhynox);
6634 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6635 for(Int_t i=0; i<4; i++)
6636 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6637 endcapcoverplatecliptrans[i]);
6638 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6639 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6640 - fgkEndCapCoverPlateLength[0]
6641 - fgkEndCapSideCoverThickness,
6642 0.5*(fgkEndCapCoverPlateDownClipWidth
6643 - fgkEndCapCoverPlateClipWidth),
6644 0.5*(fgkEndCapSideCoverThickness
6645 + fgkEndCapCoverPlateThickness)
6646 - fgkEndCapSideCoverWidth[1]
6647 - fgkEndCapSideCoverThickness);
6648 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6649 - fgkEndCapCoverPlateLength[0]
6650 - fgkEndCapSideCoverThickness,
6651 0.5*(fgkEndCapCoverPlateDownClipWidth
6652 - fgkEndCapCoverPlateClipWidth)
6653 + fgkEndCapSideCoverLength[2]
6654 - fgkEndCapCoverPlateDownClipWidth,
6655 0.5*(fgkEndCapSideCoverThickness
6656 + fgkEndCapCoverPlateThickness)
6657 - fgkEndCapSideCoverWidth[1]
6658 - fgkEndCapSideCoverThickness);
6659 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6660 - fgkEndCapCoverPlateLength[0]
6661 + fgkEndCapSideCoverThickness
6662 + fgkEndCapCoverPlateLength[1]
6663 + 2.0*fgkEndCapCoverPlateLength[0]
6664 - fgkEndCapCoverPlateDownClipLength,
6665 0.5*(fgkEndCapCoverPlateDownClipWidth
6666 - fgkEndCapCoverPlateClipWidth),
6667 0.5*(fgkEndCapSideCoverThickness
6668 + fgkEndCapCoverPlateThickness)
6669 - fgkEndCapSideCoverWidth[1]
6670 - fgkEndCapSideCoverThickness);
6671 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6672 - fgkEndCapCoverPlateLength[0]
6673 + fgkEndCapSideCoverThickness
6674 + fgkEndCapCoverPlateLength[1]
6675 + 2.0*fgkEndCapCoverPlateLength[0]
6676 - fgkEndCapCoverPlateDownClipLength,
6677 0.5*(fgkEndCapCoverPlateDownClipWidth
6678 - fgkEndCapCoverPlateClipWidth)
6679 + fgkEndCapSideCoverLength[2]
6680 - fgkEndCapCoverPlateDownClipWidth,
6681 0.5*(fgkEndCapSideCoverThickness
6682 + fgkEndCapCoverPlateThickness)
6683 - fgkEndCapSideCoverWidth[1]
6684 - fgkEndCapSideCoverThickness);
6685 for(Int_t i=0; i<4; i++)
6686 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6687 endcapcoverplatedowncliptrans[i]);
6688 /////////////////////////////////////////////////////
6689 // Placing Kapton Foil
6690 /////////////////////////////////////////////////////
6691 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6692 0.5*fgkEndCapKaptonFoilWidth,
6693 0.5*fgkEndCapKaptonFoilThickness);
6694 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6695 endcapkaptonfoilshape,
6696 fSSDKaptonFlexMedium);
6697 endcapkaptonfoil->SetLineColor(8);
6698 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6699 0.5*fgkEndCapKaptonFoilWidth
6700 - 0.5*fgkEndCapCoverPlateClipWidth,
6701 0.5*fgkEndCapCoverPlateThickness
6702 - 0.5*fgkEndCapKaptonFoilThickness
6703 - fgkEndCapSideCoverWidth[1]
6704 - fgkEndCapSideCoverThickness);
6705 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6706 /////////////////////////////////////////////////////////////
6707 // Placing Electronic Tubes
6708 /////////////////////////////////////////////////////////////
6709 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6710 - fgkEndCapInterfaceCardBThickness
6711 - 9.*fgkEndCapStripConnectionThickness
6712 - 8.*fgkEndCapCardElectBoardBackThickness,
6713 fgkEndCapKaptonFoilWidth
6714 - fgkEndCapInterfaceCardBThickness
6715 - 9.*fgkEndCapStripConnectionThickness
6716 - 8.*fgkEndCapCardElectBoardBackThickness
6717 - fgkEndCapInterfaceElectBoardCardBThickness};
6718 TGeoVolume* endcapeffectivecables[2];
6719 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6720 fgkEndCapEffectiveCableRadiusMax,
6721 endcapeffectivecableswidth[0],
6722 10,"EndCapEffectiveCables1");
6723 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6724 fgkEndCapEffectiveCableRadiusMax,
6725 endcapeffectivecableswidth[1],
6726 25,"EndCapEffectiveCables2");
6727 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6728 TGeoTranslation* endcapeffectivecablestrans[2];
6729 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6730 - 0.5*endcapeffectivecableswidth[0]
6731 - 0.5*(fgkEndCapCoverPlateWidth[0]
6732 - fgkEndCapCoverPlateWidth[2]
6733 - (kendcapcoverplatesmallholenumber-1)
6734 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6735 + fgkEndCapSideCoverLength[2],
6736 - 0.5*fgkEndCapCoverPlateThickness
6737 - (fgkEndCapCardElectBoardBackWidth[0]
6738 - fgkEndCapInterfaceCardBWidth[0]
6739 - fgkEndCapInterfaceCardBWidth[1]));
6740 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6741 - 0.5*endcapeffectivecableswidth[1]
6742 - 0.5*(fgkEndCapCoverPlateWidth[0]
6743 - fgkEndCapCoverPlateWidth[2]
6744 - (kendcapcoverplatesmallholenumber-1)
6745 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6746 + fgkEndCapSideCoverLength[2],
6747 - 0.5*fgkEndCapCoverPlateThickness
6748 - (fgkEndCapCardElectBoardBackWidth[0]
6749 - fgkEndCapInterfaceCardBWidth[0])
6750 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6751 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6752 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6753 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6754 *endcapeffectivecablesrot);
6755 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6756 *endcapeffectivecablesrot);
6757 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6758 endcapeffectivecablescombitrans[0]);
6759 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6760 endcapeffectivecablescombitrans[1]);
6761 /////////////////////////////////////////////////////////////
6762 // Placing End Cap Cards
6763 /////////////////////////////////////////////////////////////
6764 TGeoVolume** endcapcards = GetEndCapCards();
6765 TGeoRotation* endcapcardsrot[2];
6766 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6767 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6768 TGeoTranslation* endcapcardstrans[2];
6769 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6770 - fgkEndCapCardElectBoardBackLength[0]));
6771 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6772 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6773 TGeoHMatrix* endcapcardsmatrix[2];
6774 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6775 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6776 - fgkEndCapCardJMDConnectorLength[0]
6777 - fgkEndCapInterfaceCardBThickness
6778 - 9.*fgkEndCapStripConnectionThickness
6779 - 8.*fgkEndCapCardElectBoardBackThickness;
6780 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6781 - fgkEndCapCoverPlateLength[0]
6782 + 0.5 * (fgkEndCapCoverPlateLength[3]
6783 + 2.0 * fgkEndCapCoverPlateLength[2]),
6784 - stiffenertransx-fgkEndCapStiffenerWidth
6785 - fgkEndCapCardJMDConnectorLength[0]
6786 - fgkEndCapInterfaceCardBThickness
6787 - 2.0 * fgkEndCapStripConnectionThickness
6788 - 1.5 * fgkEndCapInterfaceCardBThickness
6789 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6790 - fgkEndCapCoverPlateWidth[2]
6791 - (kendcapcoverplatesmallholenumber-1)
6792 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6793 + fgkEndCapKaptonFoilWidth,
6794 0.5*fgkEndCapCoverPlateThickness
6795 - fgkEndCapSideCoverWidth[1]);
6796 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6797 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6798 /////////////////////////////////////////////////////////////
6799 // Deallocating memory
6800 /////////////////////////////////////////////////////////////
6801 delete endcapcoverplaterot;
6802 delete endcapcoverplatecombitrans;
6803 delete endcapcoverplatetrans;
6804 for(Int_t i=0; i<3; i++){
6805 delete endcapsidecovercombitrans[i];
6806 if(i<2) delete endcapsidecoverot[i];
6807 }
6808 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6809 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6810 delete endcapcardsmatrix[0];
6811 return endcapassembly;
6812 }
6813 ////////////////////////////////////////////////////////////////////////////////
6814 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6815 Double_t radiusmax,
6816 Double_t width,
6817 Int_t ncables,
6818 char* volname){
6819 /////////////////////////////////////////////////////////////
6820 // Generating EndCap High Voltage Tubes
6821 /////////////////////////////////////////////////////////////
6822 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6823 Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.)
6824 + TMath::Power(radiusmax,2.)
6825 - TMath::Power(radiusmin,2.));
6826 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6827 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6828 effectiveouteradius,0.5*width);
6829 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6830 effectiveinnertubeshape,
6831 fSSDStiffenerConnectorMedium);
6832 effectiveinnertube->SetLineColor(41);
6833 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6834 effectiveoutertubeshape,
6835 fSSDKaptonChipCableMedium);
6836 effectiveoutertube->SetLineColor(39);
6837 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6838 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6839 effectivemothertube->AddNode(effectiveinnertube,1);
6840 effectivemothertube->AddNode(effectiveoutertube,1);
6841 return effectivemothertube;
6842 }
6843 ////////////////////////////////////////////////////////////////////////////////
6844 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6845 /////////////////////////////////////////////////////////////
6846 // Generating EndCap Support Layer 5 and Layer 6
6847 /////////////////////////////////////////////////////////////
6848 const Int_t knedges = 5;
6849 ///////////////////////////////////////////////
6850 // Setting the vertices for TGeoXtru Up Volume
6851 ///////////////////////////////////////////////
6852 const Int_t klayernumber = 2;
6853 Double_t xupvertex[klayernumber][knedges+3];
6854 Double_t yupvertex[klayernumber][knedges+3];
6855 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6856 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6857 Double_t middlepsi[klayernumber] = {0.0,0.0};
6858 for(Int_t i=0; i<klayernumber; i++){
6859 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6860 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6861 xupvertex[i][2] = -xupvertex[i][1];
6862 xupvertex[i][3] = -xupvertex[i][0];
6863
6864 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6865 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6866 yupvertex[i][2] = yupvertex[i][1];
6867 yupvertex[i][3] = yupvertex[i][0];
6868
6869 middledgeangle[i] = upedgeangle[i]/knedges;
6870 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6871 for(Int_t j=1; j<knedges; j++){
6872 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6873 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6874 }
6875 }
6876 ////////////////////////////////////
6877 // Generating Up TGeoXtru
6878 ////////////////////////////////////
6879 TGeoXtru* upendcapsupportshape[klayernumber];
6880 TGeoVolume* upendcapsupport[klayernumber];
6881 char upendcapsupportname[30];
6882 for(Int_t i=0; i<klayernumber; i++){
6883 upendcapsupportshape[i] = new TGeoXtru(2);
6884 sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6885 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6886 upendcapsupportshape[i]->DefineSection(0,0.);
6887 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6888 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
6889 fSSDCoolingTubePhynox);
6890// upendcapsupport[i]->SetLineColor(fColorPhynox);
6891 upendcapsupport[i]->SetLineColor(5);
6892 }
6893 ///////////////////////////////////////////////
6894 // Setting the vertices for TGeoXtru Down Volume
6895 ///////////////////////////////////////////////
6896 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6897 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6898 for(Int_t i=0; i<klayernumber; i++){
6899 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6900 xdownvertex[i][1] = xupvertex[i][0];
6901 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6902 ydownvertex[i][1] = yupvertex[i][0];
6903 for(Int_t j=0; j<knedges; j++){
6904 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6905 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6906 }
6907 for(Int_t j=0; j<knedges; j++){
6908 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6909 * CosD(middlepsi[i]+j*middledgeangle[i]);
6910 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6911 * SinD(middlepsi[i]+j*middledgeangle[i]);
6912 }
6913 }
6914 ////////////////////////////////////
6915 // Generating Down TGeoXtru
6916 ////////////////////////////////////
6917 TGeoXtru* downendcapsupportshape[klayernumber];
6918 TGeoVolume* downendcapsupport[klayernumber];
6919 char downendcapsupportname[30];
6920 for(Int_t i=0; i<klayernumber; i++){
6921 downendcapsupportshape[i] = new TGeoXtru(2);
6922 sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
6923 downendcapsupportshape[i] = new TGeoXtru(2);
6924 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6925 if(i==0){
6926 downendcapsupportshape[i]->DefineSection(0,0.);
6927 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6928 }
6929 else{
6930 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6931 - fgkEndCapSupportLowWidth[i]);
6932 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6933 }
6934 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
6935 downendcapsupportshape[i],fSSDCoolingTubePhynox);
6936// downendcapsupport[i]->SetLineColor(fColorPhynox);
6937 downendcapsupport[i]->SetLineColor(5);
6938 }
6939 ///////////////////////////////////////////////
6940 // Setting TGeoPgon Volume
6941 ///////////////////////////////////////////////
6942 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6943 fgkSSDLay6LadderNumber};
6944 TGeoPgon* endcapsupportmothershape[klayernumber];
6945 TGeoVolume** endcapsupportmother;
6946 endcapsupportmother = new TGeoVolume*[klayernumber];
6947 char endcapsupportmothername[30];
6948 for(Int_t i=0; i<klayernumber; i++){
6949 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6950 sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
6951 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6952 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6953 ydownvertex[i][0],yupvertex[i][1]);
6954 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
6955 fSSDCoolingTubePhynox);
6956 }
6957 ////////////////////////////////////
6958 TGeoRotation** endcapsupportrot[klayernumber];
6959 for(Int_t i=0; i<2; i++){
6960 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6961 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6962 endcapsupportrot[i][j] = new TGeoRotation();
6963 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6964 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6965 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6966 }
6967 }
6968 return endcapsupportmother;
6969 }
6970 ////////////////////////////////////////////////////////////////////////////////
6971 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6972 /////////////////////////////////////////////////////////////
6973 // Setting End Cap Support Layer 5 and 6.
6974 /////////////////////////////////////////////////////////////
6975 const Int_t kendcapcoverplatesmallholenumber = 9;
6976 const Int_t klayernumber = 2;
6977 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6978 fgkSSDLay6LadderNumber};
6979 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6980 360.0/kssdlayladdernumber[1]};
6981 TGeoVolume** endcapsupport = EndCapSupport();
6982 TGeoVolume** endcapassembly = GetEndCapAssembly();
6983 TGeoPgon* endcapsupportshape[klayernumber];
6984 Double_t* radiusmin[klayernumber];
6985 Double_t* radiusmax[klayernumber];
6986 for(Int_t i=0; i<klayernumber; i++){
6987 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6988 radiusmin[i] = endcapsupportshape[i]->GetRmin();
6989 radiusmax[i] = endcapsupportshape[i]->GetRmax();
6990 }
6991 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6992 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6993 endcapassemblyshape->GetDY(),
6994 endcapassemblyshape->GetDZ()};
6995 ///////////////////////////////////////////////
6996 // Setting TGeoPgon Volume for Mother Container
6997 ///////////////////////////////////////////////
6998 TGeoPgon* endcapsupportsystemshape[klayernumber];
6999 char endcapsupportsystemothername[30];
7000 for(Int_t i=0; i<klayernumber; i++){
7001 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7002 sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
7003 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
7004 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
7005 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7006 +2.*endcapassemblycenter[2])
7007 /CosD(0.5*upedgeangle[i]));
7008 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7009 -(fgkEndCapCoverPlateWidth[1]
7010 - fgkEndCapCoverPlateWidth[0]),
7011 *radiusmin[i],
7012 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7013 +2.*endcapassemblycenter[2])
7014 /CosD(0.5*upedgeangle[i]));
7015 }
e5bf64ae 7016 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 7017 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7018 endcapsupportsystemshape[0],fSSDAir);
7019 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7020 endcapsupportsystemshape[0],fSSDAir);
7021 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7022 endcapsupportsystemshape[1],fSSDAir);
7023 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7024 endcapsupportsystemshape[1],fSSDAir);
7025 ///////////////////////////////////////////////
7026 TGeoTranslation* endcapassemblytrans[klayernumber];
7027 for(Int_t i=0; i<klayernumber; i++)
7028 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7029 - fgkEndCapSideCoverThickness
7030 + endcapassemblycenter[0],
7031 - 0.5*fgkEndCapCoverPlateThickness
7032 - 2.0*fgkEndCapCoolingTubeRadiusMax
7033 + 2.0*endcapassemblycenter[2]
7034 + 0.5*fgkEndCapSupportLength[i]
7035 / TanD(0.5*upedgeangle[i]),
7036 0.5*(fgkEndCapCoverPlateWidth[0]
7037 - fgkEndCapCoverPlateWidth[2]
7038 - (kendcapcoverplatesmallholenumber-1)
7039 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
7040 TGeoRotation** endcapassemblyrot[klayernumber];
7041 TGeoHMatrix** endcapassemblymatrix[klayernumber];
7042 for(Int_t i=0; i<klayernumber; i++){
7043 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7044 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7045 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7046 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7047 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7048 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7049 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7050 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7051 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7052 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7053 }
7054 }
7055 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7056 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7057 for(Int_t i=0; i<2*klayernumber; i++){
7058 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7059 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7060 endcapassemblymatrix[1][j+2]);
7061 }
7062 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7063 }
7064 /////////////////////////////////////////////////////////////
7065 // Deallocating memory
7066 /////////////////////////////////////////////////////////////
7067 for(Int_t i=0; i<klayernumber; i++){
7068 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7069 delete endcapassemblyrot[i][j];
7070 }
7071 delete endcapassemblyrot[i];
7072 delete endcapassemblymatrix[i][0];
7073 delete endcapassemblymatrix[i][1];
7074 }
7075 /////////////////////////////////////////////////////////////
7076 }
7077 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7078 /////////////////////////////////////////////////////////////
7079 // Setting End Cap Support + End Cap Assembly of Layer 5.
7080 /////////////////////////////////////////////////////////////
7081 if (! moth) {
7082 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, mother is null!\n");
7083 return;
7084 };
e5bf64ae 7085 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7086 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7087 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7088 fgkEndCapSupportCenterLay5ITSPosition
7089 + fgkEndCapSupportCenterLay5Position
7090 - fgkEndCapSideCoverLength[2]);
7091 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7092 fgkEndCapSideCoverLength[2]
7093 - fgkEndCapSupportCenterLay5Position
7094 - fgkEndCapSupportCenterLay5ITSPosition);
7095 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7096 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7097 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7098 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7099 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7100 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7101 /////////////////////////////////////////////////////////////
7102 // Deallocating memory
7103 /////////////////////////////////////////////////////////////
7104 delete endcapsupportsystemrot;
7105 delete endcapsupportsystemITSCentertrans[1];
7106 }
7107 /////////////////////////////////////////////////////////////
7108 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7109 /////////////////////////////////////////////////////////////
7110 // Setting End Cap Support + End Cap Assembly of Layer 6.
7111 /////////////////////////////////////////////////////////////
7112 if (! moth) {
7113 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
7114 return;
7115 };
e5bf64ae 7116 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7117 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7118 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7119 fgkEndCapSupportCenterLay6ITSPosition
7120 + fgkEndCapSupportCenterLay6Position
7121 - fgkEndCapSideCoverLength[2]);
7122 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7123 fgkEndCapSideCoverLength[2]
7124 - fgkEndCapSupportCenterLay6Position
7125 - fgkEndCapSupportCenterLay6ITSPosition);
7126 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7127 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7128 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7129 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7130 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7131 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7132 /////////////////////////////////////////////////////////////
7133 // Deallocating memory
7134 /////////////////////////////////////////////////////////////
7135 delete endcapsupportsystemrot;
7136 delete endcapsupportsystemITSCentertrans[1];
7137 }
7138 ////////////////////////////////////////////////////////////////////////////////
7139 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7140 /////////////////////////////////////////////////////////////
7141 // Setting Ladder Support of Layer 5.
7142 /////////////////////////////////////////////////////////////
7143 if (! moth) {
7144 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
7145 return;
7146 };
7147 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7148 fMotherVol = moth;
7149 TGeoTranslation* centerITSRingSupportLay5trans[2];
7150 for(Int_t i=0; i<2; i++){
7151 centerITSRingSupportLay5trans[i] =
7152 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7153 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7154 }
7155 }
7156 ////////////////////////////////////////////////////////////////////////////////
7157 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7158 /////////////////////////////////////////////////////////////
7159 // Setting Ladder Support of Layer 6.
7160 /////////////////////////////////////////////////////////////
7161 if (! moth) {
7162 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
7163 return;
7164 };
7165 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7166 fMotherVol = moth;
7167 TGeoTranslation* centerITSRingSupportLay6trans[2];
7168 for(Int_t i=0; i<2; i++){
7169 centerITSRingSupportLay6trans[i] =
7170 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7171 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7172 }
7173 }
7174 ////////////////////////////////////////////////////////////////////////////////
d7599219 7175TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
44285dfa 7176 Double_t height, char* shapename, Int_t isign) const{
7177 /////////////////////////////////////////////////////////////
7178 // Method generating an Arb shape
7179 /////////////////////////////////////////////////////////////
7180 const Int_t kvertexnumber = 8;
7181 const Int_t ktransvectnumber = 2;
7182 TVector3* vertex[kvertexnumber];
7183 TVector3* transvector[2];
7184 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
7185 /////////////////////////////////////////////////////////////
d7599219 7186 //Setting the vertices for TGeoArb8
44285dfa 7187 /////////////////////////////////////////////////////////////
7188 vertex[0] = new TVector3(*vertexpos[0]);
7189 vertex[1] = new TVector3(*vertexpos[1]);
7190 vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
7191 vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
7192 vertex[4] = new TVector3(*vertexpos[2]);
7193 vertex[5] = new TVector3(*vertexpos[3]);
7194 vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
7195 vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
7196 /////////////////////////////////////////////////////////////
7197 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
7198 for(Int_t i = 0; i<kvertexnumber;i++)
7199 arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
bf210566 7200 /////////////////////////////////////////////////////////////
7201 // Deallocating memory
7202 /////////////////////////////////////////////////////////////
7203 for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
7204 for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
7205 /////////////////////////////////////////////////////////////
44285dfa 7206 return arbshape;
d7599219 7207}
bf210566 7208///////////////////////////////////////////////////////////////////////////////
7209TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
7210 Double_t rmax, Int_t nedges, Double_t height){
7211 /////////////////////////////////////////////////////////////
7212 // Method generating Arc shape
7213 /////////////////////////////////////////////////////////////
7214 const Int_t kvertexnumber = 2*nedges+2;
7215 TGeoXtru* arcshape = new TGeoXtru(2);
7216 TVector3** vertexposition[2];
7217 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
7218 Double_t angle = 0.;
7219 for(Int_t i=0; i<nedges+1; i++){
7220 angle = 90.+0.5*phi-i*(phi/nedges);
7221 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
7222 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
7223 }
7224 Double_t *xvertexpoints = new Double_t[kvertexnumber];
7225 Double_t *yvertexpoints = new Double_t[kvertexnumber];
7226 for(Int_t i=0; i<kvertexnumber; i++){
7227 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
7228 yvertexpoints[i] = vertexposition[0][i]->Y();
7229 }
7230 else if(i>=1&&i<nedges+2)
7231 {
7232 xvertexpoints[i] = vertexposition[1][i-1]->X();
7233 yvertexpoints[i] = vertexposition[1][i-1]->Y();
7234 }
7235 else
7236 {
7237 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
7238 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
7239 }
7240 }
7241 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
7242 arcshape->DefineSection(0,-0.5*height);
7243 arcshape->DefineSection(1,0.5*height);
44285dfa 7244 /////////////////////////////////////////////////////////////
bf210566 7245 // Deallocating memory
44285dfa 7246 /////////////////////////////////////////////////////////////
bf210566 7247 for(Int_t i=0; i<2; i++){
7248 for(Int_t j=0; j<nedges+1; j++)
7249 delete vertexposition[i][j];
7250 delete [] vertexposition[i];
7251 }
7252 delete [] xvertexpoints;
7253 delete [] yvertexpoints;
7254 /////////////////////////////////////////////////////////////
7255 return arcshape;
d7599219 7256}
7257////////////////////////////////////////////////////////////////////////////////
9b0c60ab 7258TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
7259 ///////////////////////////////////////////////////////////////////////
7260 // Method Generating the Screw Shape
7261 // radius[0]: outer radius
7262 // radius[1]: inner radius
7263 // edgesnumber[0]: outer number of edges
7264 // edgesnumber[1]: inner number of edges
7265 // section[0]: lower section position
7266 // section[1]: higher section position
7267 ///////////////////////////////////////////////////////////////////////
7268 Double_t outradius = radius[0];
7269 Double_t inradius = radius[1];
7270 Int_t outvertexnumber = edgesnumber[0];
7271 Int_t invertexnumber = edgesnumber[1];
7272 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7273 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7274 for(Int_t i=0; i<outvertexnumber+1; i++){
7275 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
7276 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
7277 }
7278 for(Int_t i=0; i<invertexnumber+1; i++){
7279 xscrewvertex[outvertexnumber+i+1] = inradius*CosD(90.-i*360./invertexnumber);
7280 yscrewvertex[outvertexnumber+i+1] = inradius*SinD(90.-i*360./invertexnumber);
7281 }
7282 TGeoXtru* screwshape = new TGeoXtru(2);
7283 screwshape->DefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex);
7284 screwshape->DefineSection(0,section[0]);
7285 screwshape->DefineSection(1,section[1]);
7286 delete [] xscrewvertex;
7287 delete [] yscrewvertex;
7288 return screwshape;
7289}
7290////////////////////////////////////////////////////////////////////////////////
7291TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
7292 ///////////////////////////////////////////////////////////////////////
7293 // Method Generating the Hole Shape
7294 // radius of the Hole
7295 // nedges: number of edges to approximate the circle
7296 ///////////////////////////////////////////////////////////////////////
7297 Int_t vertexnumber = nedges+6;
7298 Double_t* xholevertex = new Double_t[vertexnumber];
7299 Double_t* yholevertex = new Double_t[vertexnumber];
7300 xholevertex[0] = radius;
7301 xholevertex[1] = xholevertex[0];
7302 xholevertex[2] = -xholevertex[1];
7303 xholevertex[3] = xholevertex[2];
7304 xholevertex[4] = xholevertex[0];
7305 yholevertex[0] = 0.;
7306 yholevertex[1] = -radius;
7307 yholevertex[2] = yholevertex[1];
7308 yholevertex[3] = -yholevertex[1];
7309 yholevertex[4] = yholevertex[3];
7310 for(Int_t i=0; i<nedges+1; i++){
7311 xholevertex[i+5] = radius*CosD(i*360./nedges);
7312 yholevertex[i+5] = radius*SinD(i*360./nedges);
7313 }
7314 TGeoXtru* holeshape = new TGeoXtru(2);
7315 holeshape->DefinePolygon(vertexnumber,xholevertex,yholevertex);
7316 holeshape->DefineSection(0,section[0]);
7317 holeshape->DefineSection(1,section[1]);
7318 delete [] xholevertex;
7319 delete [] yholevertex;
7320 return holeshape;
7321}
7322////////////////////////////////////////////////////////////////////////////////
44285dfa 7323TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
7324 /////////////////////////////////////////////////////////////
7325 // Given an axis specified by param, it gives the reflection of the point
7326 // respect to the axis
7327 /////////////////////////////////////////////////////////////
7328 TVector3* n = new TVector3(param[0],param[1],param[2]);
7329 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
7330 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 7331 /////////////////////////////////////////////////////////////
7332 // Deallocating memory
7333 /////////////////////////////////////////////////////////////
7334 delete n;
7335 /////////////////////////////////////////////////////////////
44285dfa 7336 return reflectedvector;
d7599219 7337}
7338////////////////////////////////////////////////////////////////////////////////
bf210566 7339TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
d7599219 7340 Double_t dx,
7341 Double_t dy,
7342 Double_t dz) const{
44285dfa 7343 /////////////////////////////////////////////////////////////
d7599219 7344 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 7345 /////////////////////////////////////////////////////////////
bf210566 7346 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
7347 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 7348 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 7349 hmatrix->SetTranslation(newvect);
7350 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
7351 delete hmatrix;
7352 return matrix;
d7599219 7353}
7354////////////////////////////////////////////////////////////////////////////////
d7599219 7355TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 7356 /////////////////////////////////////////////////////////////
7357 // Method returning the Medium type
7358 /////////////////////////////////////////////////////////////
d7599219 7359 char ch[30];
7360 sprintf(ch, "ITS_%s",mediumName);
7361 TGeoMedium* medium = gGeoManager->GetMedium(ch);
7362 if (! medium)
7363 printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
7364 return medium;
7365}
7366////////////////////////////////////////////////////////////////////////////////
d7599219 7367void AliITSv11GeometrySSD::CreateMaterials(){
7368///////////////////////////////////
7369// This part has to be modified
7370///////////////////////////////////
7371 ///////////////////////////////////
7372 // Silicon for Sensor
7373 ///////////////////////////////////
bf210566 7374 fSSDSensorMedium = GetMedium("SI$");
d7599219 7375 ///////////////////////////////////
7376 // Silicon Mixture for Sensor
7377 ///////////////////////////////////
44285dfa 7378 fSSDChipMedium = GetMedium("SPD SI CHIP$");
7379 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 7380 ///////////////////////////////////
7381 // Stiffener Components Materials
7382 ///////////////////////////////////
bf210566 7383 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 7384 ///////////////////////////
7385 // Stiffener Connectors
7386 ///////////////////////////
bf210566 7387 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 7388 ////////////////////////////////
7389 // Stiffener 0603-1812 Capacitor
7390 ////////////////////////////////
bf210566 7391 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
7392 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
d7599219 7393 ///////////////////////////
7394 // Stiffener Hybrid Wire
7395 ///////////////////////////
bf210566 7396 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 7397 ///////////////////////////
7398 // Al for Cooling Block
7399 ///////////////////////////
bf210566 7400 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 7401 //////////////////////////////////////////////////////
7402 // Kapton and Al for Chip Cable Flex and Ladder Cables
7403 //////////////////////////////////////////////////////
bf210566 7404 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7405 fSSDAlTraceChipCableMedium = GetMedium("AL$");
7406 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
7407 fSSDAlTraceFlexMedium = GetMedium("AL$");
7408 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7409 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 7410 /////////////////////////////////////////////////////////////////
7411 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
7412 //////////////////////////////////////////////////////////////////
44285dfa 7413 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 7414 /////////////////////////////////////////////////////////////////
7415 // G10 for Detector Leg, TubeHolder
7416 //////////////////////////////////////////////////////////////////
44285dfa 7417 fSSDTubeHolderMedium = GetMedium("G10FR4$");
7418 fSSDSensorSupportMedium = GetMedium("G10FR4$");
7419 fSSDMountingBlockMedium = GetMedium("G10FR4$");
7420 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 7421 /////////////////////////////////////////////////////////////////
7422 // Water and Phynox for Cooling Tube
7423 //////////////////////////////////////////////////////////////////
bf210566 7424 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 7425 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 7426 /////////////////////////////////////////////////////////////////////
9b0c60ab 7427 // Material for Support Rings
7428 /////////////////////////////////////////////////////////////////////
7429 fSSDSupportRingAl = GetMedium("AL$");
7430 /////////////////////////////////////////////////////////////////////
bf210566 7431 fSSDAir = GetMedium("SDD AIR$");
7432 fCreateMaterials = kTRUE;
d7599219 7433}
7434/////////////////////////////////////////////////////////////////////
e5bf64ae 7435