]> 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
Parameters for track finding in AliITStrackerSA added to AliITSRecoParam (F. Prino)
[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/////////////////////////////////////////////////////////////////////////////////
02d4acf9 42const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5";
43const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6";
bf210566 44/////////////////////////////////////////////////////////////////////////////////
d7599219 45//Parameters for SSD Geometry
46/////////////////////////////////////////////////////////////////////////////////
e21cdd03 47// Variable for Vertical Disalignement of Modules
48/////////////////////////////////////////////////////////////////////////////////
02d4acf9 49const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
e21cdd03 50/////////////////////////////////////////////////////////////////////////////////
d7599219 51// Layer5 (lengths are in mm and angles in degrees)
52/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 53const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
d7599219 54const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
55const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
9acf2ecc 56const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
57const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
58const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
d7599219 59/////////////////////////////////////////////////////////////////////////////////
60// Layer6 (lengths are in mm and angles in degrees)
61/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 62const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
d7599219 63const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
64const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
9acf2ecc 65const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
66const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
67const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
d7599219 68/////////////////////////////////////////////////////////////////////////////////
69// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
70/////////////////////////////////////////////////////////////////////////////////
71const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
9acf2ecc 72const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
73const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
74const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
75const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
bf210566 76const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
77const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
9acf2ecc 78const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
d7599219 79/////////////////////////////////////////////////////////////////////////////////
80// Stiffener (lengths are in mm and angles in degrees)
81/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 82const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
83const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
bf210566 84//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 3.315;
9acf2ecc 85const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm;
86const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
bf210566 87const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
9acf2ecc 88const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
89const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
90const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
91const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
bf210566 92const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 0.700*fgkmm; // multiplied by 0.5
9acf2ecc 93const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
94const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
bf210566 95const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] =
96 {44.32*fgkmm, 0.33*fgkmm};
97const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
98const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
99const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
d7599219 100const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight =
bf210566 101 0.25*fgkSSDStiffenerHeight;
102const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
103const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
d7599219 104/////////////////////////////////////////////////////////////////////////////////
105// Cooling Block (lengths are in mm and angles in degrees)
106/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 107const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
108const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
bf210566 109const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
110 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
d7599219 111const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
bf210566 112 {1.000*fgkmm, 0.120*fgkmm};
d7599219 113const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
bf210566 114 {1.900*fgkmm, 0.400*fgkmm};
d7599219 115const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
9acf2ecc 116 1.500*fgkmm;
d7599219 117const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
9acf2ecc 118 0.300*fgkmm;
d7599219 119/////////////////////////////////////////////////////////////////////////////////
120// SSD Sensor (lengths are in mm and angles in degrees)
121/////////////////////////////////////////////////////////////////////////////////
122const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
bf210566 123 "SSDSensorSensitiveVol";
9acf2ecc 124const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
125const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
126const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
d7599219 127const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
9acf2ecc 128 fgkSSDSensorLength-39.1*fgkmm;
bf210566 129const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
130const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
d7599219 131/////////////////////////////////////////////////////////////////////////////////
132// Flex (lengths are in mm and angles in degrees)
133/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 134const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
d7599219 135const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
bf210566 136 {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
137 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
138 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
139 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
140 - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
d7599219 141const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
bf210566 142 { 9.340*fgkmm, 5.380*fgkmm};
d7599219 143const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
bf210566 144 { 0.030*fgkmm, 0.020*fgkmm};
d7599219 145const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
9acf2ecc 146const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
147const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
d7599219 148const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
bf210566 149 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
d7599219 150const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
bf210566 151 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
d7599219 152/////////////////////////////////////////////////////////////////////////////////
153// SSD Ladder Cable (lengths are in mm and angles in degrees)
154/////////////////////////////////////////////////////////////////////////////////
bf210566 155const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
d7599219 156/////////////////////////////////////////////////////////////////////////////////
157// SSD Module (lengths are in mm and angles in degrees)
158/////////////////////////////////////////////////////////////////////////////////
159const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
bf210566 160 { 1.000*fgkmm, 3.900*fgkmm};
d7599219 161const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
9acf2ecc 162 45.600*fgkmm;
d7599219 163const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
9acf2ecc 164 5.075*fgkmm;
d7599219 165/////////////////////////////////////////////////////////////////////////////////
166// Sensor Support (lengths are in mm and angles in degrees)
167/////////////////////////////////////////////////////////////////////////////////
bf210566 168const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
169 5.800*fgkmm;
d7599219 170const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
bf210566 171 2.000*fgkmm;
d7599219 172const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
bf210566 173 { 4.620*fgkmm, 5.180*fgkmm};
174const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
175 { 0.450*fgkmm, 0.450*fgkmm};
176const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
177 = 0.5 * (fgkSSDModuleSensorSupportDistance
178 + fgkSSDSensorSideSupportThickness[0])
179 - fgkSSDSensorSideSupportLength;
d7599219 180const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
bf210566 181 5.250*fgkmm;
d7599219 182const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
bf210566 183 1.680*fgkmm;
184const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
185 = {fgkSSDSensorSideSupportHeight[0]
186 + fgkSSDSensorSideSupportThickness[0],
187 fgkSSDSensorSideSupportHeight[1]
188 + fgkSSDSensorSideSupportThickness[1]};
189const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
190 = {fgkSSDSensorSideSupportThickness[0],
191 fgkSSDSensorSideSupportThickness[1]};
d7599219 192const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
bf210566 193 19.000*fgkmm;
d7599219 194/////////////////////////////////////////////////////////////////////////////////
195// Chip Cables (lengths are in mm and angles in degrees)
196/////////////////////////////////////////////////////////////////////////////////
197const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
bf210566 198 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
d7599219 199const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
bf210566 200 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
201 - (fgkSSDSensorSideSupportHeight[1]
202 - fgkSSDSensorSideSupportHeight[0])
203 - fgkSSDCoolingBlockHoleCenter
204 - fgkSSDStiffenerHeight
205 - fgkSSDChipHeight-fgkSSDSensorHeight,
206 fgkSSDModuleCoolingBlockToSensor
207 - fgkSSDCoolingBlockHoleCenter
208 - fgkSSDStiffenerHeight
209 - fgkSSDChipHeight-fgkSSDSensorHeight};
d7599219 210const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
bf210566 211 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
d7599219 212/////////////////////////////////////////////////////////////////////////////////
213// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
214/////////////////////////////////////////////////////////////////////////////////
215const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
bf210566 216 3.820*fgkmm;
217//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
218// 3.780;
d7599219 219const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
bf210566 220 fgkSSDSensorLength-fgkSSDSensorOverlap;
d7599219 221const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
bf210566 222 { 0.86*fgkmm, 0.30*fgkmm};
d7599219 223const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
bf210566 224 { 30.00, 90.00};
d7599219 225const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
bf210566 226 1.78*fgkmm;
d7599219 227/////////////////////////////////////////////////////////////////////////////////
228//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
229/////////////////////////////////////////////////////////////////////////////////
bf210566 230const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
231 = fgkSSDModuleSensorSupportDistance
232 - 2. * fgkCarbonFiberJunctionToSensorSupport;
233const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
d7599219 234const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
bf210566 235 { 0.751*fgkmm, 0.482*fgkmm};
236const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
237 1.630*fgkmm;
238const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
239const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
240 = fgkCarbonFiberTriangleLength
241 - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
242 / TMath::Cos(fgkCarbonFiberTriangleAngle
243 * TMath::DegToRad());
244const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
245 = 0.5*(fgkCarbonFiberJunctionWidth
246 - fgkCarbonFiberSupportWidth)
247 - fgkCarbonFiberSupportTopEdgeDist[0]
248 - fgkCarbonFiberSupportWidth;
d7599219 249/////////////////////////////////////////////////////////////////////////////////
250// Carbon Fiber Lower Support Parameters (lengths are in mm)
251/////////////////////////////////////////////////////////////////////////////////
252const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
9acf2ecc 253 = 0.950*fgkmm;
d7599219 254const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
9acf2ecc 255 = 1.600*fgkmm;
d7599219 256const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
9acf2ecc 257 = 0.830*fgkmm;
d7599219 258const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
259 = 0.5*fgkCarbonFiberSupportWidth;
260const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
bf210566 261 = fgkCarbonFiberJunctionWidth
262 - 2. * (fgkCarbonFiberLowerSupportWidth
263 + fgkCarbonFiberLowerSupportVolumeSeparation);
d7599219 264const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
bf210566 265 = {fgkCarbonFiberLowerSupportWidth
266 + fgkCarbonFiberLowerSupportVolumeSeparation,
267 fgkCarbonFiberLowerSupportWidth
268 + fgkCarbonFiberLowerSupportVolumeSeparation
269 + fgkCarbonFiberLowerSupportTransverseWidth};
d7599219 270/////////////////////////////////////////////////////////////////////////////////
271// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
272/////////////////////////////////////////////////////////////////////////////////
273const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
bf210566 274 {0.5 * (fgkSSDLay5LadderLength
275 - fgkSSDLay5SensorsNumber
276 * fgkCarbonFiberJunctionWidth
277 - fgkCarbonFiberLowerSupportWidth),
278 0.5 * (fgkSSDLay5LadderLength
279 - fgkSSDLay5SensorsNumber
280 * fgkCarbonFiberJunctionWidth
281 + fgkCarbonFiberLowerSupportWidth)};
d7599219 282const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
bf210566 283 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
284 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
d7599219 285const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
bf210566 286 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
287 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
9b0c60ab 288const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
289 {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
d7599219 290/////////////////////////////////////////////////////////////////////////////////
291// Cooling Tube Support (lengths are in mm and angles in degrees)
292/////////////////////////////////////////////////////////////////////////////////
bf210566 293const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
d7599219 294const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
295 = fgkSSDCoolingBlockHoleRadius[0];
bf210566 296const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
297const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
298const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
d7599219 299const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
bf210566 300 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
301const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
302 11.70*fgkmm;
d7599219 303/////////////////////////////////////////////////////////////////////////////////
304// Cooling Tube (lengths are in mm and angles in degrees)
305/////////////////////////////////////////////////////////////////////////////////
bf210566 306const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
307const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm;
308const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
d7599219 309 fgkCarbonFiberJunctionWidth;
310const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
bf210566 311 fgkSSDModuleSensorSupportDistance
312 + fgkSSDCoolingBlockLength;
9b0c60ab 313const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
d7599219 314/////////////////////////////////////////////////////////////////////////////////
315// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
316/////////////////////////////////////////////////////////////////////////////////
317const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
bf210566 318 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
d7599219 319const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
bf210566 320 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
d7599219 321const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
bf210566 322 20.0*fgkmm;
d7599219 323const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
bf210566 324 40.0;
d7599219 325const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
326 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
327const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
bf210566 328 2.5*fgkmm;
d7599219 329const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
bf210566 330 { 56.0*fgkmm, 12.0*fgkmm};
d7599219 331const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
bf210566 332 { 5.0*fgkmm, 2.9*fgkmm};
d7599219 333const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
bf210566 334 1.0*fgkmm;
d7599219 335const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
bf210566 336 6.0*fgkmm;
d7599219 337const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth =
bf210566 338 4.0*fgkmm;
d7599219 339const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
bf210566 340 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
d7599219 341/////////////////////////////////////////////////////////////////////////////////
9b0c60ab 342// SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
343/////////////////////////////////////////////////////////////////////////////////
344const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
345const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
346const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
347const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
348const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
349/////////////////////////////////////////////////////////////////////////////////
350// SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
351/////////////////////////////////////////////////////////////////////////////////
352const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
353const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
354const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
355 - fgkSSDMountingBlockHeight[1]
356 + 0.5*fgkCoolingTubeSupportHeight
357 + fgkSSDModuleCoolingBlockToSensor
e21cdd03 358 + fgkSSDModuleVerticalDisalignment
9b0c60ab 359 - fgkMountingBlockSupportDownHeight,
360 fgkSSDLay6RadiusMin
361 - fgkSSDMountingBlockHeight[1]
362 + 0.5*fgkCoolingTubeSupportHeight
363 + fgkSSDModuleCoolingBlockToSensor
e21cdd03 364 + fgkSSDModuleVerticalDisalignment
9b0c60ab 365 - fgkMountingBlockSupportDownHeight};
366const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
367 - fgkSSDMountingBlockHeight[1]
368 + 0.5*fgkCoolingTubeSupportHeight
369 + fgkSSDModuleCoolingBlockToSensor
e21cdd03 370 + fgkSSDModuleVerticalDisalignment
9b0c60ab 371 - fgkMountingBlockSupportRadius[0],
372 fgkSSDLay6RadiusMax
373 - fgkSSDMountingBlockHeight[1]
374 + 0.5*fgkCoolingTubeSupportHeight
375 + fgkSSDModuleCoolingBlockToSensor
e21cdd03 376 + fgkSSDModuleVerticalDisalignment
9b0c60ab 377 - fgkMountingBlockSupportRadius[1]};
378const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
379const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
380const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
381/////////////////////////////////////////////////////////////////////////////////
382// SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
383/////////////////////////////////////////////////////////////////////////////////
384const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
385const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
386const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
387const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
388 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
389const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
390 {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
391const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
392 {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
393const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
394const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
395const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
396const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
397const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
398const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
399/////////////////////////////////////////////////////////////////////////////////
400// SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
401/////////////////////////////////////////////////////////////////////////////////
402const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
403const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
404const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
405/////////////////////////////////////////////////////////////////////////////////
406// SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
407/////////////////////////////////////////////////////////////////////////////////
408const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
409 {10.5*fgkmm,9.25*fgkmm};
410const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
411const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
412const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
413 {182.3,177.9,84.4,70.0,35.0};
414const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
415 {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
416const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
417/////////////////////////////////////////////////////////////////////////////////
418// SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
419/////////////////////////////////////////////////////////////////////////////////
420const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
421 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
422const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
423 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
424 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
425const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
426/////////////////////////////////////////////////////////////////////////////////
427// SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
428/////////////////////////////////////////////////////////////////////////////////
429const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
430 {62.0*fgkmm,21.87*fgkmm};
431const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
432 {47.1*fgkmm,0.35*fgkmm};
433const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
434 1.0*fgkmm;
435const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
436const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
437 {43.5*fgkmm, 0.70*fgkmm};
438const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
439 0.15*fgkmm;
440const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
441 19.0*fgkmm;
442const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
443 {4.80*fgkmm,1.1*fgkmm};
444const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
445 {3.3*fgkmm,1.10*fgkmm};
446const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
447 2.1*fgkmm;
448const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
449 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
450const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
451 {1.9*fgkmm,0.15*fgkmm};
452const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
453 19*fgkmm;
454const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
455 1.0*fgkmm;
456const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
457 3.6*fgkmm;
458const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
459 61.0*fgkmm;
460const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
461 5.97*fgkmm;
462const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
463const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
464 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
465 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
466const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
467 {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
468const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
469 1.0*fgkmm;
470const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
471 = 0.15*fgkmm;
472const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
473 20.0*fgkmm;
474const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
475const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
476const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
477const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
478const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
479/////////////////////////////////////////////////////////////////////////////////
480// SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
481/////////////////////////////////////////////////////////////////////////////////
482const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
483const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
484const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {365.0*fgkmm,430.0*fgkmm};
485const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
486const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
487const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
488const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
489const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
490const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
491/////////////////////////////////////////////////////////////////////////////////
44285dfa 492ClassImp(AliITSv11GeometrySSD)
493/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 494AliITSv11GeometrySSD::AliITSv11GeometrySSD():
495 AliITSv11Geometry(),
44285dfa 496 fSSDChipMedium(),
497 fSSDChipGlueMedium(),
498 fSSDStiffenerMedium(),
499 fSSDStiffenerConnectorMedium(),
500 fSSDStiffener0603CapacitorMedium(),
501 fSSDStiffener1812CapacitorMedium(),
502 fSSDStiffenerHybridWireMedium(),
503 fSSDKaptonFlexMedium(),
504 fSSDAlTraceFlexMedium(),
505 fSSDAlTraceLadderCableMedium(),
506 fSSDKaptonLadderCableMedium(),
507 fSSDKaptonChipCableMedium(),
508 fSSDAlTraceChipCableMedium(),
509 fSSDAlCoolBlockMedium(),
510 fSSDSensorMedium(),
511 fSSDSensorSupportMedium(),
512 fSSDCarbonFiberMedium(),
513 fSSDTubeHolderMedium(),
514 fSSDCoolingTubeWater(),
515 fSSDCoolingTubePhynox(),
9b0c60ab 516 fSSDSupportRingAl(),
44285dfa 517 fSSDMountingBlockMedium(),
bf210566 518 fSSDAir(),
519 fCreateMaterials(kFALSE),
520 fTransformationMatrices(kFALSE),
521 fBasicObjects(kFALSE),
522 fcarbonfiberjunction(),
523 fcoolingtubesupport(),
524 fhybridmatrix(),
525 fssdcoolingblocksystem(),
526 fcoolingblocksystematrix(),
527 fssdstiffenerflex(),
528 fssdendflex(),
9b0c60ab 529 fendladdercoolingtubesupportmatrix(),
bf210566 530 fendladdermountingblock(),
9b0c60ab 531 fendladdermountingblockclip(),
bf210566 532 fSSDSensor5(),
533 fSSDSensor6(),
534 fSSDLayer5(),
535 fSSDLayer6(),
536 fMotherVol(),
9b0c60ab 537 fLay5LadderSupportRing(),
538 fLay6LadderSupportRing(),
e5bf64ae 539 fgkEndCapSupportSystem(),
44285dfa 540 fColorCarbonFiber(4),
541 fColorRyton(5),
bf210566 542 fColorPhynox(14),
44285dfa 543 fColorSilicon(3),
bf210566 544 fColorAl(38),
44285dfa 545 fColorKapton(6),
546 fColorPolyhamide(5),
547 fColorStiffener(9),
bf210566 548 fColorEpoxy(30),
549 fColorWater(7),
550 fColorG10(41)
44285dfa 551{
552 ////////////////////////
553 // Standard constructor
554 ////////////////////////
44285dfa 555}
556/////////////////////////////////////////////////////////////////////////////////
557AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
9acf2ecc 558 AliITSv11Geometry(s.GetDebug()),
44285dfa 559 fSSDChipMedium(s.fSSDChipMedium),
560 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
561 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
562 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
563 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
564 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
565 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
566 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
567 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
568 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
569 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
570 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
571 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
572 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
573 fSSDSensorMedium(s.fSSDSensorMedium),
574 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
575 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
576 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
577 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
578 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
9b0c60ab 579 fSSDSupportRingAl(s.fSSDSupportRingAl),
44285dfa 580 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
bf210566 581 fSSDAir(s.fSSDAir),
582 fCreateMaterials(s.fCreateMaterials),
583 fTransformationMatrices(s.fTransformationMatrices),
584 fBasicObjects(s.fBasicObjects),
585 fcarbonfiberjunction(s.fcarbonfiberjunction),
586 fcoolingtubesupport(s.fcoolingtubesupport),
587 fhybridmatrix(s.fhybridmatrix),
588 fssdcoolingblocksystem(s.fssdcoolingblocksystem),
589 fcoolingblocksystematrix(s.fcoolingblocksystematrix),
590 fssdstiffenerflex(s.fssdstiffenerflex),
591 fssdendflex(s.fssdendflex),
9b0c60ab 592 fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
bf210566 593 fendladdermountingblock(s.fendladdermountingblock),
9b0c60ab 594 fendladdermountingblockclip(s.fendladdermountingblockclip),
bf210566 595 fSSDSensor5(s.fSSDSensor5),
596 fSSDSensor6(s.fSSDSensor6),
597 fSSDLayer5(s.fSSDLayer5),
598 fSSDLayer6(s.fSSDLayer6),
44285dfa 599 fMotherVol(s.fMotherVol),
9b0c60ab 600 fLay5LadderSupportRing(s.fLay5LadderSupportRing),
601 fLay6LadderSupportRing(s.fLay6LadderSupportRing),
e5bf64ae 602 fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
44285dfa 603 fColorCarbonFiber(s.fColorCarbonFiber),
604 fColorRyton(s.fColorRyton),
605 fColorPhynox(s.fColorPhynox),
606 fColorSilicon(s.fColorSilicon),
607 fColorAl(s.fColorAl),
608 fColorKapton(s.fColorKapton),
609 fColorPolyhamide(s.fColorPolyhamide),
610 fColorStiffener(s.fColorStiffener),
bf210566 611 fColorEpoxy(s.fColorEpoxy),
612 fColorWater(s.fColorWater),
613 fColorG10(s.fColorG10)
44285dfa 614{
615 ////////////////////////
616 // Copy Constructor
617 ////////////////////////
d7599219 618}
619/////////////////////////////////////////////////////////////////////////////////
44285dfa 620AliITSv11GeometrySSD& AliITSv11GeometrySSD::
621operator=(const AliITSv11GeometrySSD &s){
622 ////////////////////////
623 // Assignment operator
624 ////////////////////////
625 this->~AliITSv11GeometrySSD();
626 new(this) AliITSv11GeometrySSD(s);
627 return *this;
628/*
629 if(&s == this) return *this;
630 fMotherVol = s.fMotherVol;
631 return *this;
632 */
633}
bf210566 634///////////////////////////////////////////////////////////////////////////////
635void AliITSv11GeometrySSD::CreateTransformationMatrices(){
636 ///////////////////////////////////////////////////////////////////////
637 // Method generating the trasformation matrix for the whole SSD Geometry
638 ///////////////////////////////////////////////////////////////////////
639 // Setting some variables for Carbon Fiber Supportmatrix creation
640 //////////////////////////////////////////////////////////////////////
641 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
642 * CosD(fgkCarbonFiberJunctionAngle[0]);
643 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
644 + fgkCarbonFiberSupportTopEdgeDist[0]
645 + fgkCarbonFiberSupportWidth);
646 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
647 * TanD(fgkCarbonFiberJunctionAngle[0]);
648 TGeoRotation* carbonfiberot[3];
649 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
650 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
651 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
652 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
653 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
654 * CosD(fgkCarbonFiberTriangleAngle),0.,
655 - fgkCarbonFiberTriangleLength
656 * SinD(fgkCarbonFiberTriangleAngle)};
657 ///////////////////////////////////////////
658 //Setting Local Translations and Rotations:
659 ///////////////////////////////////////////
660 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
661 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
662 0.5*carbonfibersupportheight,NULL);
663 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
664 2.*symmetryplaneposition+transvector[1],
665 transvector[2], carbonfiberot[2]);
666 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
667 /////////////////////////////////////////////////////////////
668 // Carbon Fiber Support Transformations
669 /////////////////////////////////////////////////////////////
670 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
671 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
672 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
673 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
674 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
675 }
676 /////////////////////////////////////////////////////////////
677 // Carbon Fiber Junction Transformation
678 /////////////////////////////////////////////////////////////
679 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
680 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
681 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
682 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
683 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
684 localcarbonfiberjunctionmatrix[i] =
685 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
686 localcarbonfiberjunctionrot[i] =
687 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
688 localcarbonfiberjunctiontrans[i] =
689 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 690 }
bf210566 691 ///////////////////////
692 // Setting Translations
693 ///////////////////////
694 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
695 localcarbonfiberjunctiontrans[1][0] =
696 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
697 localcarbonfiberjunctiontrans[2][0] =
698 new TGeoTranslation(fgkCarbonFiberTriangleLength
699 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
700 fgkCarbonFiberTriangleLength
701 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
702 localcarbonfiberjunctiontrans[0][1] =
703 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
704 localcarbonfiberjunctiontrans[1][1] =
705 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
706 localcarbonfiberjunctiontrans[2][1] =
707 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
708 ////////////////////
709 // Setting Rotations
710 ////////////////////
711 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
712 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
713 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
714 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
715 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
716 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
717 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
718 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
719 ////////////////////////////////////////
720 // Setting Carbon Fiber Junction matrix
721 ////////////////////////////////////////
722 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
723 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
724 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
725 localcarbonfiberjunctionmatrix[i][j] =
726 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
727 *localcarbonfiberjunctionrot[i][j]);
728 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
729 }
d7599219 730 }
bf210566 731 /////////////////////////////////////////////////////////////
732 // Carbon Fiber Lower Support Transformations
733 /////////////////////////////////////////////////////////////
734 TGeoTranslation* localcarbonfiberlowersupportrans[2];
735 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
736 fgkCarbonFiberLowerSupportVolumePosition[1]
737 + fgkCarbonFiberLowerSupportVolumePosition[0],
738 0.0);
739 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
740 fgkCarbonFiberJunctionWidth
741 - fgkCarbonFiberLowerSupportWidth
742 - fgkCarbonFiberLowerSupportVolumePosition[0]
743 - fgkCarbonFiberLowerSupportVolumePosition[1],
744 - 0.5*fgkCarbonFiberLowerSupportHeight);
745 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
746 fcarbonfiberlowersupportrans[0] =
747 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
748 fcarbonfiberlowersupportrans[1] =
749 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
750 /////////////////////////////////////////////////////////////
751 // SSD Sensor Support Transformations
752 /////////////////////////////////////////////////////////////
753 const Int_t kssdsensorsupportmatrixnumber = 3;
754 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
755 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
756 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
757 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
758 localssdsensorsupportmatrix[i] =
759 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
760 localssdsensorsupportrot[i] =
761 new TGeoRotation*[kssdsensorsupportmatrixnumber];
762 localssdsensorsupportrans[i] =
763 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 764 }
bf210566 765 ///////////////////////
766 // Setting Translations
767 ///////////////////////
768 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
769 0.5*fgkSSDSensorSideSupportWidth,
770 0.0);
771 localssdsensorsupportrans[1][0] =
772 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
773 localssdsensorsupportrans[2][0] =
774 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
775 localssdsensorsupportrans[0][1] =
776 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
777 0.5*fgkSSDSensorSideSupportThickness[0],
778 0.0);
779 localssdsensorsupportrans[1][1] =
780 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
781 - 0.5*fgkSSDSensorSideSupportThickness[0]
782 - fgkSSDModuleSensorSupportDistance,
783 0.0);
784 localssdsensorsupportrans[2][1] =
785 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
786 - fgkSSDSensorCenterSupportPosition,
787 0.5*fgkSSDSensorCenterSupportWidth
788 - 0.5*fgkSSDModuleSensorSupportDistance,
789 fgkSSDSensorCenterSupportThickness[0]);
790 localssdsensorsupportrans[0][2] =
791 new TGeoTranslation(fgkCarbonFiberTriangleLength
792 + fgkCarbonFiberJunctionToSensorSupport,
793 fgkCarbonFiberJunctionWidth
794 - 0.5*(fgkCarbonFiberLowerSupportWidth
795 + fgkSSDSensorCenterSupportLength
796 - fgkSSDSensorCenterSupportThickness[0])
797 - fgkSSDSensorCenterSupportPosition,
798 0.0);
799 localssdsensorsupportrans[1][2] =
800 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
801 localssdsensorsupportrans[2][2] =
802 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
803 ////////////////////
804 // Setting Rotations
805 ////////////////////
806 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
807 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
808 localssdsensorsupportrot[i][j] = new TGeoRotation();
809 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
810 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
811 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 812 }
bf210566 813 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
814 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
815 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
816 ////////////////////////////////////////
817 // SSD Sensor Support matrix
818 ////////////////////////////////////////
819 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
820 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
821 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
822 localssdsensorsupportmatrix[i][j] =
823 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
824 *localssdsensorsupportrot[i][j]);
825 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
826 }
d7599219 827 }
44285dfa 828 /////////////////////////////////////////////////////////////
bf210566 829 // SSD Cooling Tube Support Transformations
44285dfa 830 /////////////////////////////////////////////////////////////
bf210566 831 const Int_t kcoolingtubesupportmatrixnumber = 2;
832 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
833 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
834 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 835 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 836 /fgkCoolingTubeSupportRmax);
bf210566 837 localcoolingtubesupportrans[0] =
838 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 839 + 2.*(fgkCoolingTubeSupportLength
44285dfa 840 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 841 + fgkCarbonFiberTriangleLength
bf210566 842 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
843 localcoolingtubesupportrans[1] =
844 new TGeoTranslation(fgkCarbonFiberJunctionLength
845 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
846 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
847 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
848 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
849 - 0.5*(fgkCarbonFiberLowerSupportWidth
850 + fgkSSDSensorCenterSupportLength
851 - fgkSSDSensorCenterSupportThickness[0])
852 + 0.5*fgkSSDSensorLength,
853 - 0.5*fgkCoolingTubeSupportHeight);
854 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
855 localcoolingtubesupportrot[i] = new TGeoRotation();
856 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
857 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
858 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
859 localcoolingtubesupportmatrix[i] =
860 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
861 *localcoolingtubesupportrot[i]);
862 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
863 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
864 (*localcoolingtubesupportmatrix[0]));
865 /////////////////////////////////////////////////////////////
9b0c60ab 866 // End Ladder SSD Cooling Tube Support Transformations
867 /////////////////////////////////////////////////////////////
868 TGeoTranslation** localendladdercooltubetrans[2];
869 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
870 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
871 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
872 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
873 - (fgkCoolingTubeSupportLength
874 - fgkCoolingTubeSupportRmax),
875 fgkEndLadderMountingBlockPosition[0]
876 - fgkendladdercoolingsupportdistance[0]
877 + 0.5*fgkCoolingTubeSupportWidth,
878 - 0.5*fgkCoolingTubeSupportHeight);
879 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
880 - (fgkCoolingTubeSupportLength
881 - fgkCoolingTubeSupportRmax),
882 fgkEndLadderMountingBlockPosition[0]
883 + fgkendladdercoolingsupportdistance[1]
884 + 0.5*fgkCoolingTubeSupportWidth,
885 - 0.5*fgkCoolingTubeSupportHeight);
886 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
887 - fgkCoolingTubeSupportRmax)
888 + fgkCarbonFiberTriangleLength
889 - 2.0*fgkCarbonFiberJunctionLength,
890 0.0,
891 0.0);
892 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
893 fgkendladdercoolingsupportdistance[0]
894 + fgkendladdercoolingsupportdistance[1],
895 0.0);
896 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
897 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
898 + fgkCarbonFiberJunctionLength
899 - fgkCoolingTubeSupportLength,
900 fgkEndLadderCarbonFiberLowerJunctionLength[1]
901 - 0.5*fgkCoolingTubeSupportWidth
902 -fgkendladdercoolingsupportdistance[2],
903 - 0.5*fgkCoolingTubeSupportHeight);
904 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
905 + fgkCoolingTubeSupportLength
906 - fgkCoolingTubeSupportRmax
907 - fgkCarbonFiberJunctionLength,
908 fgkEndLadderCarbonFiberLowerJunctionLength[1]
909 - 0.5*fgkCoolingTubeSupportWidth
910 - fgkendladdercoolingsupportdistance[2],
911 - 0.5*fgkCoolingTubeSupportHeight);
912 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
913 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
914 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
915 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
916 (*localcoolingtubesupportrot[1]));
917 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
918 (*localcoolingtubesupportrot[1]));
919 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
920 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
921 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
922 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
923 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
924
925 fendladdercoolingtubesupportmatrix[1][0] =
926 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
927 *(*localcoolingtubesupportrot[1]));
928 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
929 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
930 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
931 /////////////////////////////////////////////////////////////
bf210566 932 // SSD Cooling Tube Transformations
933 /////////////////////////////////////////////////////////////
934 TGeoRotation* localcoolingtuberot = new TGeoRotation();
935 localcoolingtuberot->SetAngles(0.,90.,0.);
936 TGeoTranslation** localcoolingtubetrans[4];
937 TVector3** localcoolingtubevect[4];
938 for(Int_t i=0; i<4; i++){
939 localcoolingtubevect[i] = new TVector3*[2];
940 localcoolingtubetrans[i] = new TGeoTranslation*[2];
941 fcoolingtubematrix[i] = new TGeoHMatrix*[2];
d7599219 942 }
bf210566 943 localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
944 -fgkCarbonFiberTriangleLength),
945 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
946 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
947 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
948 - 0.5*(fgkCarbonFiberLowerSupportWidth
949 + fgkSSDSensorCenterSupportLength
950 - fgkSSDSensorCenterSupportThickness[0])+
951 0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
952 - 2.0*fgkSSDModuleStiffenerPosition[1]
953 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
954 - 0.5*fgkCoolingTubeSupportWidth,
955 - 0.5*fgkCoolingTubeSupportHeight);
956 localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
957 localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
958 - 2.0*fgkSSDModuleStiffenerPosition[1]
959 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
960 + fgkCoolingTubeSupportWidth,
961 localcoolingtubevect[0][0]->Z());
962 localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
963 + fgkCarbonFiberTriangleLength,
964 localcoolingtubevect[0][0]->Y(),
965 localcoolingtubevect[0][0]->Z());
966 localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
967 + fgkCarbonFiberTriangleLength,
968 localcoolingtubevect[0][1]->Y(),
969 localcoolingtubevect[0][1]->Z());
970 localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
971 - fgkCarbonFiberTriangleLength),
972 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
973 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
974 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
975 - 0.5*(fgkCarbonFiberLowerSupportWidth
976 + fgkSSDSensorCenterSupportLength
977 - fgkSSDSensorCenterSupportThickness[0])
978 + fgkSSDModuleStiffenerPosition[1]
979 - 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
980 - 0.5*fgkCoolingTubeSupportHeight);
981 localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
982 + fgkCarbonFiberTriangleLength,
983 localcoolingtubevect[2][0]->Y(),
984 localcoolingtubevect[2][0]->Z());
985 localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
986 - fgkCarbonFiberTriangleLength),
987 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
988 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
989 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
990 - 0.5*(fgkCarbonFiberLowerSupportWidth
991 + fgkSSDSensorCenterSupportLength
992 - fgkSSDSensorCenterSupportThickness[0])
993 + fgkSSDSensorLength
994 - 0.5*fgkSSDModuleStiffenerPosition[1],
995 - 0.5*fgkCoolingTubeSupportHeight);
996 localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
997 + fgkCarbonFiberTriangleLength,
998 localcoolingtubevect[3][0]->Y(),
999 - 0.5*fgkCoolingTubeSupportHeight);
1000 for(Int_t i=0; i<4; i++)
1001 for(Int_t j=0; j<2; j++){
1002 localcoolingtubetrans[i][j] =
1003 new TGeoTranslation(localcoolingtubevect[i][j]->X(),
1004 localcoolingtubevect[i][j]->Y(),
1005 localcoolingtubevect[i][j]->Z());
1006 fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
1007 * (*localcoolingtuberot));
1008 }
1009 /////////////////////////////////////////////////////////////
9b0c60ab 1010 // SSD End Ladder Cooling Tube Transformations
1011 /////////////////////////////////////////////////////////////
1012 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1013 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1014 TGeoTranslation** localendlladdercoolingtubetrans[2];
1015 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
1016 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
1017 for(Int_t i=0; i<2; i++)
1018 for(Int_t j=0; j<(i==0?6:4); j++)
1019 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1020 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1021 - fgkCoolingTubeSupportRmax)
1022 + fgkCarbonFiberJunctionLength,
1023 0.5*(fgkEndLadderMountingBlockPosition[0]
1024 - fgkendladdercoolingsupportdistance[0]),
1025 - 0.5*fgkCoolingTubeSupportHeight);
1026 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1027 - fgkCoolingTubeSupportRmax)
1028 - fgkCarbonFiberJunctionLength
1029 + fgkCarbonFiberTriangleLength,
1030 0.5*(fgkEndLadderMountingBlockPosition[0]
1031 - fgkendladdercoolingsupportdistance[0]),
1032 - 0.5*fgkCoolingTubeSupportHeight);
1033 localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1034 - fgkCoolingTubeSupportRmax)
1035 + fgkCarbonFiberJunctionLength,
1036 fgkEndLadderMountingBlockPosition[0]
1037 - fgkendladdercoolingsupportdistance[0]
1038 + 0.5*(fgkendladdercoolingsupportdistance[0]
1039 + fgkendladdercoolingsupportdistance[1]
1040 + fgkCoolingTubeSupportWidth),
1041 - 0.5*fgkCoolingTubeSupportHeight);
1042 localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
1043 - fgkCoolingTubeSupportRmax)
1044 - fgkCarbonFiberJunctionLength
1045 + fgkCarbonFiberTriangleLength,
1046 fgkEndLadderMountingBlockPosition[0]
1047 - fgkendladdercoolingsupportdistance[0]
1048 + 0.5*(fgkendladdercoolingsupportdistance[0]
1049 + fgkendladdercoolingsupportdistance[1]
1050 + fgkCoolingTubeSupportWidth),
1051 - 0.5*fgkCoolingTubeSupportHeight);
1052 localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
1053 - fgkCoolingTubeSupportRmax)
1054 + fgkCarbonFiberJunctionLength,
1055 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1056 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1057 - fgkEndLadderMountingBlockPosition[0]
1058 - fgkendladdercoolingsupportdistance[1]
1059 - fgkCoolingTubeSupportWidth),
1060 - 0.5*fgkCoolingTubeSupportHeight);
1061 localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
1062 - fgkCoolingTubeSupportRmax)
1063 - fgkCarbonFiberJunctionLength
1064 + fgkCarbonFiberTriangleLength,
1065 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1066 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1067 - fgkEndLadderMountingBlockPosition[0]
1068 - fgkendladdercoolingsupportdistance[1]
1069 - fgkCoolingTubeSupportWidth),
1070 - 0.5*fgkCoolingTubeSupportHeight);
1071 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1072 - fgkCoolingTubeSupportRmax)
1073 + fgkCarbonFiberJunctionLength,
1074 - 0.50 * (fgkMountingBlockToSensorSupport
1075 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1076 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1077 + fgkSSDSensorOverlap
1078 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1079 - fgkendladdercoolingsupportdistance[2]
1080 - fgkEndLadderMountingBlockPosition[1]
1081 - fgkCoolingTubeSupportWidth)
1082 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1083 - fgkendladdercoolingsupportdistance[2]
1084 - fgkCoolingTubeSupportWidth,
1085 - 0.5*fgkCoolingTubeSupportHeight);
1086 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1087 - fgkCoolingTubeSupportRmax)
1088 - fgkCarbonFiberJunctionLength
1089 + fgkCarbonFiberTriangleLength,
1090 - 0.50 * (fgkMountingBlockToSensorSupport
1091 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1092 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1093 + fgkSSDSensorOverlap
1094 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1095 - fgkendladdercoolingsupportdistance[2]
1096 - fgkEndLadderMountingBlockPosition[1]
1097 - fgkCoolingTubeSupportWidth)
1098 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1099 - fgkendladdercoolingsupportdistance[2]
1100 - fgkCoolingTubeSupportWidth,
1101 - 0.5*fgkCoolingTubeSupportHeight);
1102 localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1103 - fgkCoolingTubeSupportRmax)
1104 + fgkCarbonFiberJunctionLength,
1105 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1106 - 0.5*fgkendladdercoolingsupportdistance[2],
1107 - 0.5*fgkCoolingTubeSupportHeight);
1108 localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
1109 - fgkCoolingTubeSupportRmax)
1110 - fgkCarbonFiberJunctionLength
1111 + fgkCarbonFiberTriangleLength,
1112 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1113 - 0.5*fgkendladdercoolingsupportdistance[2],
1114 - 0.5*fgkCoolingTubeSupportHeight);
1115 fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
1116 fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
1117 for(Int_t i=0; i<2; i++)
1118 for(Int_t j=0; j<(i==0?6:4); j++){
1119 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1120 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1121 }
1122 /////////////////////////////////////////////////////////////
bf210566 1123 // SSD Hybrid Components Transformations
1124 /////////////////////////////////////////////////////////////
1125 const Int_t khybridmatrixnumber = 3;
1126 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1127 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1128 0.5*fgkSSDStiffenerWidth,
1129 0.5*fgkSSDStiffenerHeight);
1130 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1131 fgkSSDModuleStiffenerPosition[1],0.0);
1132
1133 localhybridtrans[2] = new TGeoTranslation(
1134 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1135 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1136 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1137 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1138 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1139 - fgkSSDSensorCenterSupportThickness[0]),
1140 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1141 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight));
1142 fhybridmatrix = new TGeoHMatrix();
1143 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1144 /////////////////////////////////////////////////////////////
1145 // SSD Cooling Block Transformations
1146 /////////////////////////////////////////////////////////////
1147 const Int_t kcoolingblockmatrixnumber = 4;
1148 TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
1149 localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
1150 - fgkCoolingTubeSupportRmin),0.0,
1151 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1152 localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
1153 - 0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
1154 0.0,fgkSSDStiffenerHeight);
1155 localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
1156 localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
1157 fcoolingblocksystematrix = new TGeoHMatrix();
1158 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
1159 fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
1160 /////////////////////////////////////////////////////////////
1161 // SSD Stiffener Flex Transformations
1162 /////////////////////////////////////////////////////////////
1163 const Int_t klocalflexmatrixnumber = 4;
1164 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1165 for(Int_t i=0; i<fgkflexnumber; i++)
1166 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1167 for(Int_t i=0; i<fgkflexnumber; i++)
1168 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1169 localflexmatrix[i][j] = new TGeoCombiTrans();
1170 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1171 - 2.*fgkSSDModuleStiffenerPosition[1]
1172 - fgkSSDStiffenerWidth;
1173 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1174 +0.5*fgkSSDStiffenerLength,
1175 0.5*fgkSSDStiffenerWidth,
1176 -0.5*fgkSSDStiffenerHeight
1177 -0.5*fgkSSDFlexHeight[0]);
1178 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1179 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1180 -0.5*fgkSSDStiffenerWidth,
1181 -0.5*fgkSSDStiffenerHeight
1182 -0.5*fgkSSDFlexHeight[0]);
1183 TGeoRotation* localflexrot = new TGeoRotation();
1184 localflexrot->SetAngles(180.,0.,0.);
1185 localflexmatrix[1][0]->SetRotation(localflexrot);
1186 for(Int_t i=0; i<fgkflexnumber; i++)
1187 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1188 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1189 for(Int_t i=0; i<fgkflexnumber; i++){
1190 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1191 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1192 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1193 }
bf210566 1194 /////////////////////////////////////////////////////////////
1195 // SSD End Flex Transformations
1196 /////////////////////////////////////////////////////////////
1197 TGeoRotation* localendflexrot = new TGeoRotation();
1198 localendflexrot->SetAngles(0.0,90.0,0.0);
1199 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1200 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1201 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1202 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1203 * TMath::DegToRad()*ssdflexradiusmax
1204 - fgkSSDFlexLength[2]-TMath::Pi()
1205 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
1206 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1207 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1208 + fgkSSDFlexLength[2];
1209 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1210 0.5*fgkSSDFlexWidth[0],
1211 2.*fgkSSDStiffenerHeight
1212 + 0.5*fgkSSDFlexHeight[0]);
1213 localendflexmatrix->SetRotation(localendflexrot);
1214 for(Int_t i=0; i<fgkflexnumber; i++)
1215 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1216 /////////////////////////////////////////////////////////////
1217 // End Ladder Carbon Fiber Junction
1218 /////////////////////////////////////////////////////////////
1219 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1220 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1221 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1222 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1223 localendladdercarbonfiberjunctionmatrix[i]
1224 = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1225 localendladdercarbonfiberjunctionrot[i]
1226 = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1227 localendladdercarbonfiberjunctiontrans[i]
1228 = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1229 fendladdercarbonfiberjunctionmatrix[i]
1230 = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
d7599219 1231 }
bf210566 1232 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1233 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1234 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1235 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1236 }
1237 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1238 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1239 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1240 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1241 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1242 0.0,0.0);
1243 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1244 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1245 * SinD(fgkCarbonFiberTriangleAngle),
1246 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1247 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1248 }
1249 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1250 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1251 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1252 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1253 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1254 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1255 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1256 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1257 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1258 localendladdercarbonfiberjunctionglobalmatrix[i] =
1259 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1260 *localendladdercarbonfiberjunctionglobalrot[i]);
1261 }
1262 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1263 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1264 localendladdercarbonfiberjunctionmatrix[i][j] =
1265 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1266 *localendladdercarbonfiberjunctionrot[i][j]);
1267 fendladdercarbonfiberjunctionmatrix[i][j] =
1268 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1269 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1270 }
1271 /////////////////////////////////////////////////////////////
1272 // End Ladder Carbon Fiber Support
1273 /////////////////////////////////////////////////////////////
1274 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1275 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1276 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1277 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1278 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1279 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1280 }
1281 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1282 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1283 fendladdercarbonfibermatrix[i][j] =
1284 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1285 *(*fcarbonfibersupportmatrix[j]));
1286 /////////////////////////////////////////////////////////////
1287 // End Ladder SSD Mounting Block
1288 /////////////////////////////////////////////////////////////
1289 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1290 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1291 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1292 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1293 + fgkSSDMountingBlockLength[1])
1294 + 0.5*fgkCarbonFiberTriangleLength,
1295 fgkEndLadderMountingBlockPosition[i],
1296 - fgkSSDMountingBlockHeight[1]
1297 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1298 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1299 endladdermountingblockrot->SetAngles(0.,90.,0.);
1300 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1301 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1302 /////////////////////////////////////////////////////////////
1303 // End Ladder SSD Mounting Block Clip Matrix
1304 /////////////////////////////////////////////////////////////
1305 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1306 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1307
1308 TGeoRotation* localendladdercliprot = new TGeoRotation();
1309 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1310 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1311 - fgkSSDMountingBlockLength[1])
1312 + fgkSSDMountingBlockLength[0],0.,0.);
1313 localendladdercliprot->SetAngles(90.,180.,-90.);
1314 TGeoCombiTrans* localendladderclipcombitrans =
1315 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1316 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1317 for(Int_t j=0; j<2; j++){
1318 fendladdermountingblockclipmatrix[i][j] =
1319 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1320 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1321 }
bf210566 1322 /////////////////////////////////////////////////////////////
1323 // End Ladder Carbon Fiber Lower Support
1324 /////////////////////////////////////////////////////////////
1325 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1326 fendladderlowersupptrans[i] =
1327 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1328 + 0.5*fgkSSDMountingBlockWidth),
1329 - 0.5*fgkCarbonFiberLowerSupportHeight);
1330 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1331 fgkCarbonFiberLowerSupportVolumePosition[1]
1332 + fgkCarbonFiberLowerSupportVolumePosition[0],
1333 0.0);
1334 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1335 /////////////////////////////////////////////////////////////
1336 // Matrix for positioning Ladder into mother volume
1337 /////////////////////////////////////////////////////////////
1338 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1339 for(Int_t i=0; i<fgkladdernumber; i++)
1340 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1341 TGeoRotation* localladdermotherrot = new TGeoRotation();
1342 localladdermotherrot->SetAngles(0.,90.,0.);
1343 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1344 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1345 for(Int_t i=0; i<fgkladdernumber; i++){
1346 localladdermothertrans[i] = new TGeoTranslation(0.,
1347 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1348 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1349 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1350 * fgkCarbonFiberJunctionWidth,0.);
1351 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1352 *localladdermotherrot);
1353 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1354 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1355 }
44285dfa 1356 /////////////////////////////////////////////////////////////
bf210566 1357 // Ladder Cables Matrices
44285dfa 1358 /////////////////////////////////////////////////////////////
44285dfa 1359 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1360 + fgkSSDFlexHeight[1];
44285dfa 1361 Double_t ssdladdercabletransx[3];
1362 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1363 * SinD(2.*fgkSSDFlexAngle)
1364 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1365 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1366 - ssdladdercabletransx[0]
bf210566 1367 / SinD(2.*fgkSSDFlexAngle))
1368 * CosD(fgkSSDFlexAngle);
44285dfa 1369 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1370 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1371 - fgkSSDFlexLength[2]-TMath::Pi()
1372 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1373 - fgkSSDLadderCableWidth)
bf210566 1374 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1375 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1376 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1377 ssdladdercabletransx[1]
bf210566 1378 * TanD(fgkSSDFlexAngle),
44285dfa 1379 ssdladdercabletransx[2]
bf210566 1380 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1381 TGeoRotation* localladdercablerot[3];
bf210566 1382 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1383 localladdercablerot[0]->SetAngles(90.,0.,0.);
1384 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1385 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1386 * (*localladdercablerot[0]));
1387 ////////////////////////////////////////////
1388 // LocalLadderCableCombiTransMatrix
1389 ////////////////////////////////////////////
1390 const Int_t klocalladdersidecablesnumber = 2;
1391 const Int_t klocalladdercombitransnumber = 5;
1392 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1393 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1394 localladdercablecombitransmatrix[i] =
1395 new TGeoCombiTrans*[klocalladdercombitransnumber];
1396 ///////////////////////////////////////////
1397 // Left Side Ladder Cables Transformations
1398 ///////////////////////////////////////////
1399 localladdercablecombitransmatrix[0][0] =
d7599219 1400 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1401 0.,0.,NULL);
bf210566 1402 localladdercablecombitransmatrix[0][1] =
1403 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1404 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1405 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1406 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1407 - 0.5*(fgkCarbonFiberLowerSupportWidth
1408 + fgkSSDSensorCenterSupportLength
1409 - fgkSSDSensorCenterSupportThickness[0]),
1410 - (fgkSSDModuleCoolingBlockToSensor
1411 + 0.5*fgkCoolingTubeSupportHeight
1412 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1413 - fgkSSDChipHeight),NULL);
44285dfa 1414 localladdercablecombitransmatrix[0][2] =
d7599219 1415 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1416 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1417 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1418 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1419 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1420 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1421 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1422 new TGeoRotation("",180.,0.,0.));
44285dfa 1423 localladdercablecombitransmatrix[0][4] =
1424 new TGeoCombiTrans(-ssdladdercabletransx[0]
1425 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1426 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1427 0.,
1428 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1429 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1430 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1431 + ssdladdercabletransz[2],localladdercablerot[2]);
1432 ///////////////////////////////////////////
1433 // Rigth Side Ladder Cables Transformations
1434 ///////////////////////////////////////////
bf210566 1435 TGeoCombiTrans* localladdercablessdmodulematrix =
1436 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1437 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1438 fgkSSDStiffenerWidth,
1439 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1440 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1441 localladdercablecombitransmatrix[1][i] =
bf210566 1442 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1443 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1444 ///////////////////////////////////////////
bf210566 1445 // Setting LadderCableHMatrix
44285dfa 1446 ///////////////////////////////////////////
bf210566 1447 Int_t beamaxistrans[2][3];
1448 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1449 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1450 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1451 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1452 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1453 beamaxistrans[1][2] = beamaxistrans[1][0];
1454 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1455 TGeoRotation* laddercablerot = new TGeoRotation();
1456 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1457 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1458 Double_t* laddercabletransvector;
1459 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1460 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1461 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1462 }
1463 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1464 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1465 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1466 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1467 localladdercablehmatrix[i][j]->MultiplyLeft(
1468 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1469 }
1470 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1471 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1472 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1473 laddercabletransvector[1]
bf210566 1474 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1475 * fgkCarbonFiberJunctionWidth,
bf210566 1476 laddercabletransvector[2]);
1477 laddercablecombitrans->SetRotation(*laddercablerot);
1478 laddercablecombitrans->SetTranslation(*laddercabletrans);
1479 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1480 }
1481 fladdercablematrix[i][2] =
1482 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1483 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1484 fladdercablematrix[i][3] =
1485 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1486 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1487 }
1488 for(Int_t i=0; i<fgkladdercablesnumber; i++)
1489 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1490 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1491 ///////////////////////////////////////////
1492 // Setting Ladder HMatrix
1493 ///////////////////////////////////////////
1494 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1495 fgkSSDLay6SensorsNumber};
1496 for(Int_t i=0; i<fgkladdernumber; i++){
1497 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1498 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1499 fladdermatrix[i][j] = new TGeoHMatrix();
1500 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1501 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1502 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1503 }
1504 }
1505 ///////////////////////////////////////////
1506 // Setting SSD Sensor Matrix
1507 ///////////////////////////////////////////
1508 TGeoCombiTrans* localssdsensorcombitrans[2];
1509 TGeoRotation* localssdsensorrot = new TGeoRotation();
1510 localssdsensorrot->SetAngles(0.,90.,0.);
1511 TGeoTranslation* localssdsensortrans[2];
1512 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1513 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1514 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1515 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1516 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1517 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1518 - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1519 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
02d4acf9 1520 - fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment
e21cdd03 1521 + (fgkSSDSensorSideSupportHeight[1]
bf210566 1522 - fgkSSDSensorSideSupportHeight[0]));
1523 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1524 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1525 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1526 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1527 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1528 - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1529 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
02d4acf9 1530 -fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment);
bf210566 1531 for(Int_t i=0; i<2; i++)
1532 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1533 *localssdsensorrot);
1534 for(Int_t i=0; i<fgkladdernumber; i++){
1535 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1536 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1537 switch(i){
1538 case 0: //Ladder of Layer5
1539 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1540 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1541 *localssdsensorcombitrans[1])));
1542 break;
1543 case 1: //Ladder of Layer6
1544 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1545 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1546 *localssdsensorcombitrans[0])));
1547 break;
1548 }
1549 }
1550 }
1551 //////////////////////////
1552 // Setting SSD End Ladder
1553 //////////////////////////
1554 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1555 for(Int_t i=0; i<2; i++){
1556 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1557 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1558 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1559 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1560 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1561 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1562 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1563 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1564 }
1565 /////////////////////////////////////////////////////
1566 // Setting the CombiTransformation to pass ITS center
1567 /////////////////////////////////////////////////////
1568 Double_t itscentertransz[fgklayernumber];
1569 itscentertransz[0] = fgkSSDLay5LadderLength
1570 - fgkLay5CenterITSPosition;
1571 itscentertransz[1] = fgkSSDLay6LadderLength
1572 - fgkLay6CenterITSPosition;
1573 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1574 + 0.5*fgkCoolingTubeSupportHeight;
1575 TGeoRotation* itscenterrot[3];
1576 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1577 itscenterrot[0]->SetAngles(90.,180.,-90.);
1578 itscenterrot[1]->SetAngles(0.,90.,0.);
1579 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1580 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1581 for(Int_t i=0; i<fgklayernumber; i++)
1582 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1583 itssensortransy,
1584 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1585 - itscentertransz[i],itscenterrot[2]);
1586 TGeoRotation** locallayerrot[fgklayernumber];
1587 TGeoTranslation** locallayertrans[fgklayernumber];
1588 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1589 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1590 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1591 - fgkLay5CenterITSPosition);
1592 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1593 - fgkLay6CenterITSPosition);
1594 const Int_t kssdlayladdernumber[fgklayernumber] =
1595 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1596 for(Int_t i=0; i<fgklayernumber; i++){
1597 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1598 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1599 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1600 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1601 }
1602 Double_t layerladderangleposition[fgklayernumber] =
1603 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1604 Double_t layerradius = 0.;
1605 for(Int_t i=0; i<fgklayernumber; i++){
1606 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1607 switch(i){
1608 case 0: //Ladder of Layer5
1609 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1610 break;
1611 case 1: //Ladder of Layer6
1612 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1613 break;
1614 }
1615 locallayerrot[i][j] = new TGeoRotation();
1616 locallayertrans[i][j] = new TGeoTranslation();
1617 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1618 locallayertrans[i][j]->SetTranslation(layerradius
1619 * CosD(90.0+j*layerladderangleposition[i]),
1620 layerradius
1621 * SinD(90.0+j*layerladderangleposition[i]),0.);
1622 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1623 *locallayerrot[i][j]);
1624 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1625 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1626 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1627 }
1628 }
44285dfa 1629 /////////////////////////////////////////////////////////////
bf210566 1630 // Deallocating memory
44285dfa 1631 /////////////////////////////////////////////////////////////
bf210566 1632 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1633 delete carbonfiberot[i];
1634 delete localcarbonfibersupportmatrix[i];
1635 }
1636 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1637 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1638 delete localcarbonfiberjunctionmatrix[i][j];
1639 delete localcarbonfiberjunctionrot[i][j];
1640 delete localcarbonfiberjunctiontrans[i][j];
1641 }
1642 delete [] localcarbonfiberjunctionmatrix[i];
1643 delete [] localcarbonfiberjunctionrot[i];
1644 delete [] localcarbonfiberjunctiontrans[i];
1645 }
1646 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1647 delete localcarbonfiberlowersupportrans[i];
1648 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1649 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1650 delete localssdsensorsupportmatrix[i][j];
1651 delete localssdsensorsupportrot[i][j];
1652 delete localssdsensorsupportrans[i][j];
1653 }
1654 delete [] localssdsensorsupportmatrix[i];
1655 delete [] localssdsensorsupportrot[i];
1656 delete [] localssdsensorsupportrans[i];
1657 }
1658 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1659 delete localcoolingtubesupportmatrix[i];
1660 delete localcoolingtubesupportrot[i];
1661 delete localcoolingtubesupportrans[i];
1662 }
1663 for(Int_t i=0; i<4; i++){
1664 for(Int_t j=0; j<2; j++){
1665 delete localcoolingtubevect[i][j];
1666 delete localcoolingtubetrans[i][j];
1667 }
1668 delete [] localcoolingtubevect[i];
1669 delete [] localcoolingtubetrans[i];
1670 }
9b0c60ab 1671 delete endladdermountingblockrot;
bf210566 1672 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1673 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
1674 for(Int_t i=0; i<fgkflexnumber; i++){
1675 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1676 delete localflexmatrix[i][j];
1677 delete [] localflexmatrix[i];
1678 }
9b0c60ab 1679 delete localendlladdercoolingtuberot;
1680 for(Int_t i=0; i<2; i++){
1681 for(Int_t j=0; j<(i==0?6:4); j++)
1682 delete localendlladdercoolingtubetrans[i][j];
1683 delete [] localendlladdercoolingtubetrans[i];
1684 }
1685
bf210566 1686 delete localflexrot;
1687 delete localendflexrot;
1688 delete localendflexmatrix;
1689 for(Int_t i=0; i<fgkladdernumber; i++){
1690 delete localladdermothertrans[i];
1691 delete localladdermothercombitrans[i];
1692 }
1693 delete localladdermotherrot;
1694 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1695 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1696 delete localendladdercarbonfiberjunctionmatrix[i][j];
1697 delete localendladdercarbonfiberjunctionrot[i][j];
1698 delete localendladdercarbonfiberjunctiontrans[i][j];
1699 }
1700 delete [] localendladdercarbonfiberjunctionmatrix[i];
1701 delete [] localendladdercarbonfiberjunctionrot[i];
1702 delete [] localendladdercarbonfiberjunctiontrans[i];
1703 delete localendladdercarbonfiberjunctionglobalrot[i];
1704 delete localendladdercarbonfiberjunctionglobaltrans[i];
1705 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1706 }
9b0c60ab 1707 for(Int_t i=0; i<2; i++){
1708 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1709 delete [] localendladdercooltubetrans[i];
1710 }
1711 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1712 delete localendladdercarbonfibertrans[i];
1713 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1714 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1715 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1716 delete localladdercablecombitransmatrix[i][j];
1717 delete []localladdercablecombitransmatrix[i];
1718 }
9b0c60ab 1719 delete localendladdercliprot;
1720 delete localendladdercliptrans;
bf210566 1721 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1722 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1723 delete localladdercablehmatrix[i][j];
1724 delete []localladdercablehmatrix[i];
1725 }
1726 delete laddercablerot;
1727 delete laddercabletrans;
1728 delete laddercablecombitrans;
1729 delete localladdercablessdmodulematrix;
1730 delete localssdsensorrot;
1731 for(Int_t i=0; i<2; i++){
1732 delete localssdsensortrans[i];
1733 delete localssdsensorcombitrans[i];
1734 }
1735 for(Int_t i=0; i<fgklayernumber; i++){
1736 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1737 delete locallayerrot[i][j];
1738 delete locallayertrans[i][j];
1739 delete locallayercombitrans[i][j];
1740 }
1741 delete [] locallayerrot[i];
1742 delete [] locallayertrans[i];
1743 delete [] locallayercombitrans[i];
1744 delete localbeamaxistrans[i];
1745 }
1746 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1747 for(Int_t i=0; i<fgkladdernumber; i++){
1748 for(Int_t j=0; j<fgkladdernumber; j++)
1749 delete ladderglobalmatrix[i][j];
1750 delete [] ladderglobalmatrix[i];
1751 }
1752 /////////////////////////////////////////////////////////////
1753 fTransformationMatrices = kTRUE;
d7599219 1754}
bf210566 1755///////////////////////////////////////////////////////////////////////////////
1756void AliITSv11GeometrySSD::CreateBasicObjects(){
1757 /////////////////////////////////////////////////////////////
1758 // Method generating the Objects of SSD Geometry
1759 /////////////////////////////////////////////////////////////
1760 // SSD Sensor
1761 ///////////////////////////////////
1762 SetSSDSensor();
1763 /////////////////////////////////////////////////////////////
1764 // Carbon Fiber Support
1765 /////////////////////////////////////////////////////////////
1766 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1767 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1768 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1769 /////////////////////////////////////////////////////////////
bf210566 1770 // Carbon Fiber Junction
44285dfa 1771 /////////////////////////////////////////////////////////////
bf210566 1772 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
1773 /////////////////////////////////////////////////////////////
1774 // Carbon Fiber Lower Support
1775 /////////////////////////////////////////////////////////////
1776 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1777 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1778 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1779 /////////////////////////////
1780 // SSD Sensor Support
1781 /////////////////////////////
1782 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1783 new TGeoVolume*[fgkssdsensorsupportnumber];
44285dfa 1784 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
bf210566 1785 fgkSSDSensorSideSupportThickness[1]};
1786 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1787 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1788 fgkSSDSensorSideSupportHeight[i],
1789 fgkSSDSensorSideSupportWidth,
1790 sidesupporthickness);
1791 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1792 fgkSSDSensorCenterSupportHeight[i],
1793 fgkSSDSensorCenterSupportWidth,
1794 sidesupporthickness);
1795 }
1796 /////////////////////////////////////////////////////////////
1797 // SSD Cooling Tube Support
1798 /////////////////////////////////////////////////////////////
1799 Int_t edgesnumber = 16;
1800 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1801 /////////////////////////////////////////////////////////////
1802 // SSD Hybrid
1803 /////////////////////////////////////////////////////////////
1804 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1805 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1806 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1807 /////////////////////////////////////////////////////////////
1808 // SSD Cooling Block System
1809 /////////////////////////////////////////////////////////////
1810 fssdcoolingblocksystem = GetCoolingBlockSystem();
1811 /////////////////////////////////////////////////////////////
1812 // SSD Cooling Tube
1813 /////////////////////////////////////////////////////////////
1814 TList* coolingtubelist = GetCoolingTubeList();
1815 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
1816 fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
9b0c60ab 1817 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
1818 fendladdercoolingtube[i] =
1819 (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
bf210566 1820 /////////////////////////////////////////////////////////////
1821 // SSD Flex
1822 /////////////////////////////////////////////////////////////
1823 fssdstiffenerflex = GetSSDStiffenerFlex();
1824 fssdendflex = GetSSDEndFlex();
1825 ///////////////////////////////////
1826 // End Ladder Carbon Fiber Junction
1827 ///////////////////////////////////
1828 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1829 fendladdercarbonfiberjunction[i] =
1830 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1831 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1832 fendladdercarbonfiberjunction[i][0] =
1833 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
1834 fendladdercarbonfiberjunction[i][1] =
1835 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
1836 }
1837 ///////////////////////////////////
1838 // End Ladder Mounting Block
1839 ///////////////////////////////////
1840 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1841 ///////////////////////////////////
1842 // End Ladder Mounting Block
1843 ///////////////////////////////////
1844 fendladdermountingblockclip = GetMountingBlockClip();
1845 ///////////////////////////////////
1846 // Ladder Support
1847 ///////////////////////////////////
1848 TList* laddersupportlist = GetMountingBlockSupport(20);
1849 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1850 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1851 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1852 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
bf210566 1853 /////////////////////////////////////////////////////////////
1854 // Deallocating memory
44285dfa 1855 /////////////////////////////////////////////////////////////
bf210566 1856 delete carbonfibersupportlist;
1857 delete carbonfiberlowersupportlist;
1858 delete ssdhybridcomponentslist;
9b0c60ab 1859 delete laddersupportlist;
44285dfa 1860 /////////////////////////////////////////////////////////////
bf210566 1861 fBasicObjects = kTRUE;
1862}
1863/////////////////////////////////////////////////////////////////////////////////
1864void AliITSv11GeometrySSD::SetSSDSensor(){
1865 ////////////////////////////////////////////////////////////////
1866 // Method generating SSD Sensors: it sets the private variables
1867 // fSSDSensor5, fSSDSensor6
1868 ////////////////////////////////////////////////////////////////
44285dfa 1869 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1870 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1871 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
44285dfa 1872 0.5*ssdsensitivewidth,
bf210566 1873 0.5*fgkSSDSensorHeight,
1874 0.5*ssdsensitivelength);
1875 TGeoVolume* ssdsensorsensitiveLay5 =
02d4acf9 1876 new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1877 TGeoVolume* ssdsensorsensitiveLay6 =
02d4acf9 1878 new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1879 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1880 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
44285dfa 1881 TGeoBBox* ssdsensorinsensitiveshape[2];
1882 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1883 0.5*fgkSSDSensorInsensitiveWidth,
bf210566 1884 0.5*fgkSSDSensorHeight,
1885 0.5*fgkSSDSensorLength);
44285dfa 1886 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
44285dfa 1887 0.5*ssdsensitivewidth,
bf210566 1888 0.5*fgkSSDSensorHeight,
1889 0.5*fgkSSDSensorInsensitiveWidth);
44285dfa 1890 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1891 "SSDSensorInsensitive2"};
44285dfa 1892 TGeoVolume* ssdsensorinsensitive[2];
1893 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1894 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1895 fSSDSensorMedium);
1896 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1897 }
bf210566 1898 /////////////////////////////////////////////////////////////
1899 // Virtual Volume containing SSD Sensor
1900 /////////////////////////////////////////////////////////////
1901 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1902 0.5*fgkSSDSensorWidth,
1903 0.5*fgkSSDSensorHeight,
1904 0.5*fgkSSDSensorLength);
ef9451a3 1905 fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
bf210566 1906 fSSDAir);
ef9451a3 1907 fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
bf210566 1908 fSSDAir);
1909 /////////////////////////////////////////////////////////////
1910 for(Int_t i=0; i<4; i++){
1911 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1912 ssdsensorinsensitive[1],i<2?1:2,
1913 new TGeoTranslation(
1914 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1915 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1916 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1917 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1918 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
44285dfa 1919 ssdsensorinsensitive[1],i<2?1:2,
bf210566 1920 new TGeoTranslation(
1921 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1922 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1923 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1924 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1925 }
1926 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1927 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1928}
bf210566 1929///////////////////////////////////////////////////////////////////////////////
1930TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1931 /////////////////////////////////////////////////////////////
1932 // Method generating the Carbon Fiber Support
1933 /////////////////////////////////////////////////////////////
1934 const Int_t kvertexnumber = 4;
1935 const Int_t kshapesnumber = 2;
1936 TVector3** vertexposition[kshapesnumber];
1937 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1938 Double_t carbonfibersupportxaxisEdgeproj =
1939 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1940 * TMath::DegToRad());
1941 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1942 / fgkCarbonFiberSupportXAxisLength);
1943 /////////////////////
1944 //Vertex Positioning
1945 ////////////////////
1946 vertexposition[0][0] = new TVector3();
1947 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1948 fgkCarbonFiberSupportYAxisLength);
1949 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1950 carbonfibersupportxaxisEdgeproj
1951 * TMath::Tan(theta));
1952 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1953 - carbonfibersupportxaxisEdgeproj,
1954 fgkCarbonFiberSupportYAxisLength
1955 - vertexposition[0][2]->Y());
1956 ////////////////////////////////////////////////////
1957 //Setting the parameters for Isometry Transformation
1958 ////////////////////////////////////////////////////
1959 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1960 + fgkCarbonFiberSupportTopEdgeDist[0]
1961 + fgkCarbonFiberSupportWidth);
1962 Double_t* param = new Double_t[4];
1963 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1964 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1965 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1966 (GetReflection(vertexposition[0][j],param))->Y());
1967 char* carbonfibersupportshapename[kshapesnumber] =
1968 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1969 char* carbonfibersupportname[kshapesnumber] =
1970 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1971 TGeoArb8* carbonfibersupportshape[kshapesnumber];
1972 TGeoVolume* carbonfibersupport[kshapesnumber];
1973 TList* carbonfibersupportlist = new TList();
1974 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1975 Double_t carbonfibersupportheight =
1976 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1977 *TMath::DegToRad());
1978 for(Int_t i = 0; i< kshapesnumber; i++){
1979 carbonfibersupportshape[i] =
1980 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1981 carbonfibersupportshapename[i],i==0 ? 1: -1);
1982 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1983 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1984 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1985 carbonfibersupportlist->Add(carbonfibersupport[i]);
1986 }
1987 /////////////////////////////////////////////////////////////
1988 // Deallocating memory
1989 /////////////////////////////////////////////////////////////
1990 for(Int_t i=0; i< kshapesnumber; i++){
1991 for(Int_t j=0; j< kvertexnumber; j++)
1992 delete vertexposition[i][j];
1993 delete [] vertexposition[i];
1994 }
1995 delete [] param;
44285dfa 1996 /////////////////////////////////////////////////////////////
bf210566 1997 return carbonfibersupportlist;
d7599219 1998}
1999/////////////////////////////////////////////////////////////////////////////////
bf210566 2000TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 2001 /////////////////////////////////////////////////////////////
bf210566 2002 // Method generating SSD Carbon Fiber Junction
44285dfa 2003 /////////////////////////////////////////////////////////////
bf210566 2004 const Int_t kvertexnumber = 6;
2005 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
2006 Double_t reflectionparam[3] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
2007 * TMath::DegToRad()),-1.,0.};
2008 TVector3* vertex[kvertexnumber];
2009 vertex[0] = new TVector3();
2010 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2011 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2012 * TMath::DegToRad()),
2013 fgkCarbonFiberJunctionEdge[0]
2014 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
2015 * TMath::DegToRad()));
2016 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
2017 fgkCarbonFiberJunctionEdge[1]);
2018 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
2019 vertex[1] = GetReflection(vertex[5],reflectionparam);
2020 vertex[2] = GetReflection(vertex[4],reflectionparam);
2021 Double_t xvertexpoints[6], yvertexpoints[6];
2022 for(Int_t i=0; i<kvertexnumber; i++)
2023 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
2024 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2025 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
2026 carbonfiberjunctionshape->DefineSection(1,0.5*width);
2027 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
2028 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
2029 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
2030 /////////////////////////////////////////////////////////////
2031 // Deallocating memory
2032 /////////////////////////////////////////////////////////////
2033 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
2034 /////////////////////////////////////////////////////////////
2035 return carbonfiberjunction;
2036}
2037////////////////////////////////////////////////////////////////////////////////
2038TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
2039 /////////////////////////////////////////////////////////////
2040 // Method generating the Carbon Fiber Lower Support
2041 /////////////////////////////////////////////////////////////
2042 const Int_t kvertexnumber = 4;
2043 const Int_t kshapesnumber = 2;
2044 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
2045 fgkCarbonFiberLowerSupportWidth};
2046 TVector3** vertexposition[kshapesnumber];
2047 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2048 new TVector3*[kvertexnumber];
2049 //First Shape Vertex Positioning
2050 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2051 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2052 - fgkCarbonFiberLowerSupportLowerLenght);
2053 vertexposition[0][2] = new TVector3();
2054 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2055 //Second Shape Vertex Positioning
2056 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2057 - fgkCarbonFiberLowerSupportVolumePosition[0])
2058 / fgkCarbonFiberTriangleLength);
2059 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2060 vertexposition[0][0]->X()*TMath::Tan(theta)
2061 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2062 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2063 vertexposition[0][1]->X()*TMath::Tan(theta)
2064 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2065 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2066 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2067 fgkCarbonFiberLowerSupportVolumePosition[1]);
2068 char* carbonfiberlowersupportshapename[kshapesnumber] =
2069 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
2070 char* carbonfiberlowersupportname[kshapesnumber] =
2071 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2072 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2073 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2074 TList* carbonfiberlowersupportlist = new TList();
2075 for(Int_t i = 0; i< kshapesnumber; i++){
2076 carbonfiberlowersupportshape[i] =
2077 GetArbShape(vertexposition[i],width,
2078 fgkCarbonFiberLowerSupportHeight,
2079 carbonfiberlowersupportshapename[i]);
2080 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2081 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2082 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2083 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2084 }
2085 /////////////////////////////////////////////////////////////
2086 // Deallocating memory
2087 /////////////////////////////////////////////////////////////
2088 for(Int_t i=0; i< kshapesnumber; i++){
2089 for(Int_t j=0; j< kvertexnumber; j++)
2090 delete vertexposition[i][j];
2091 delete [] vertexposition[i];
2092 }
2093 /////////////////////////////////////////////////////////////
2094 return carbonfiberlowersupportlist;
2095}
2096///////////////////////////////////////////////////////////////////////////////
2097TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2098 Double_t width, Double_t* thickness)const{
2099 /////////////////////////////////////////////////////////////
2100 // Method generating the Sensor Support
2101 /////////////////////////////////////////////////////////////
2102 const Int_t kvertexnumber = 6;
2103 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2104 TVector3* vertexposition[kvertexnumber];
2105 vertexposition[0] = new TVector3();
2106 vertexposition[1] = new TVector3(0.0,length);
2107 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2108 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2109 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2110 vertexposition[5] = new TVector3(vertexposition[4]->X());
2111 Double_t xvertexpoints[6], yvertexpoints[6];
2112 for(Int_t i=0; i<kvertexnumber; i++)
2113 xvertexpoints[i] = vertexposition[i]->X(),
2114 yvertexpoints[i] = vertexposition[i]->Y();
2115 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2116 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2117 ssdsensorsupportshape->DefineSection(1,0.5*width);
2118 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2119 ssdsensorsupportshape,fSSDSensorSupportMedium);
2120 /////////////////////////////////////////////////////////////
2121 // Deallocating memory
2122 /////////////////////////////////////////////////////////////
2123 for (Int_t i=0; i<kvertexnumber; i++)
2124 delete vertexposition[i];
2125 /////////////////////////////////////////////////////////////
2126 return ssdsensorsupport;
2127}
2128////////////////////////////////////////////////////////////////////////////////
2129TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2130 /////////////////////////////////////////////////////////////
2131 // Method generating the Cooling Tube Support
2132 /////////////////////////////////////////////////////////////
2133 if(nedges%2!=0) nedges--;
2134 const Int_t kvertexnumber = nedges+5;
2135 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2136 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2137 Double_t angle = 90.+phi;
2138 Double_t psi = 90.-phi;
2139 ///////////////////////////////////////
2140 // Vertex Positioning for TGeoXTru
2141 ///////////////////////////////////////
2142 TVector3** vertexposition = new TVector3*[kvertexnumber];
2143 vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
2144 fgkCoolingTubeSupportRmin*SinD(angle));
2145 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2146 fgkCoolingTubeSupportRmax*SinD(angle));
2147 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2148 fgkCoolingTubeSupportRmax);
2149 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2150 fgkCoolingTubeSupportRmax);
2151 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2152 vertexposition[1]->Y());
2153 for(Int_t i=0; i<nedges; i++)
2154 vertexposition[i+5] =
2155 new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
2156 fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
2157 ///////////////////////////////////////////////////////////////////////
2158 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2159 ///////////////////////////////////////////////////////////////////////
2160 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2161 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2162 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2163 for(Int_t i=0; i<kvertexnumber; i++){
2164 xvertexpoints[i] = vertexposition[i]->X();
2165 yvertexpoints[i] = vertexposition[i]->Y();
2166 }
2167 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2168 yvertexpoints);
2169 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2170 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2171 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2172 coolingtubesupportarcshape,
2173 fSSDTubeHolderMedium);
2174 coolingtubesupportarc->SetLineColor(fColorG10);
2175 //////////////////////////////////////////////////////////////////////////
2176 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2177 //////////////////////////////////////////////////////////////////////////
2178 TGeoTubeSeg* coolingtubesupportsegshape =
2179 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2180 fgkCoolingTubeSupportRmax,
2181 0.5*fgkCoolingTubeSupportWidth,
2182 phi,360-phi);
2183 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2184 coolingtubesupportsegshape,
2185 fSSDTubeHolderMedium);
2186 coolingtubesupportseg->SetLineColor(fColorG10);
2187 //////////////////////////////////////////////////////////////////////////
2188 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2189 //////////////////////////////////////////////////////////////////////////
2190 Double_t* boxorigin = new Double_t[3];
2191 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2192 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2193 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2194 0.5*fgkCoolingTubeSupportHeight,
2195 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2196 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2197 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2198 coolingtubesupportbox->SetLineColor(fColorG10);
2199 //////////////////////////////////////////////////////////////////////////
2200 // Cooling Tube for Cooling Tube Support
2201 //////////////////////////////////////////////////////////////////////////
2202 TGeoXtru* coolingtubearcshape[2];
2203 coolingtubearcshape[0] = new TGeoXtru(2);
2204 Double_t* xvert = new Double_t[nedges+2];
2205 Double_t* yvert = new Double_t[nedges+2];
2206 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2207 ////////////////////////////////////////
2208 // Positioning the vertices for TGeoXTru
2209 ////////////////////////////////////////
2210 xvert[0] = 0., yvert[0] = 0.;
2211 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2212 for(Int_t i=0; i< nedges; i++)
2213 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2214 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2215 ////////////////////////////////////////
2216 // Defining TGeoXTru PolyGone
2217 ////////////////////////////////////////
2218 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2219 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2220 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2221 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2222 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2223 TGeoVolume* coolingtubearc[2];
2224 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2225 coolingtubearcshape[0],fSSDCoolingTubeWater);
2226 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2227 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2228 coolingtubearc[0]->SetLineColor(fColorWater);
2229 coolingtubearc[1]->SetLineColor(fColorPhynox);
2230 ////////////////////////////////////////////
2231 // Defining TGeoTubeSeg Part of Cooling Tube
2232 ////////////////////////////////////////////
2233 TGeoTubeSeg* coolingtubesegshape[2];
2234 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2235 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2236 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2237 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2238 TGeoVolume* coolingtubeseg[2];
2239 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2240 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2241 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2242 coolingtubesegshape[1],fSSDCoolingTubeWater);
2243 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2244 coolingtubeseg[1]->SetLineColor(fColorWater);
2245 /////////////////////////////////////////////////////////////
2246 // Virtual Volume containing Cooling Tube Support
2247 /////////////////////////////////////////////////////////////
2248 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2249 const Int_t kvirtualvertexnumber = 8;
2250 TVector3* virtualvertex[kvirtualvertexnumber];
2251 ////////////////////////////////////////
2252 // Positioning the vertices for TGeoXTru
2253 ////////////////////////////////////////
2254 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2255 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2256 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2257 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2258 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2259 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2260 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2261 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2262 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2263 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2264 xmothervertex[i] = virtualvertex[i]->X(),
2265 ymothervertex[i] = virtualvertex[i]->Y();
2266 ////////////////////////////////////////
2267 // Defining TGeoXTru PolyGone
2268 ////////////////////////////////////////
2269 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2270 ymothervertex);
2271 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2272 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2273 TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2274 virtualCoolingTubeSupportShape,fSSDAir);
2275 ////////////////////////////////////////
2276 // Positioning Volumes in Virtual Volume
2277 ////////////////////////////////////////
2278 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2279 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2280 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2281 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2282 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2283 virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2284 virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2285 virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2286 virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2287 /////////////////////////////////////////////////////////////
2288 // Deallocating memory
2289 /////////////////////////////////////////////////////////////
2290 delete [] vertexposition;
2291 delete xvertexpoints;
2292 delete yvertexpoints;
2293 delete xvert;
2294 delete yvert;
2295 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2296 delete virtualvertex[i];
2297 /////////////////////////////////////////////////////////////
2298 return virtualcoolingtubesupport;
2299}
2300/////////////////////////////////////////////////////////////////////////////////
2301TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2302 /////////////////////////////////////////////////////////////
2303 // Method generating List containing SSD Hybrid Components
2304 /////////////////////////////////////////////////////////////
2305 TList* ssdhybridlist = new TList();
2306 const Int_t kssdstiffenernumber = 2;
2307 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2308 - 2.*fgkSSDModuleStiffenerPosition[1]
2309 - fgkSSDStiffenerWidth;
2310 Double_t ssdchipcablesradius[kssdstiffenernumber];
2311 for(Int_t i=0; i<kssdstiffenernumber; i++)
2312 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2313 - fgkSSDChipCablesHeight[0]
2314 - fgkSSDChipCablesHeight[1]);
2315 /////////////////////////////////////////////////////////////
2316 // Mother Volumes Containers
2317 /////////////////////////////////////////////////////////////
2318 const Int_t kmothernumber = 2;
2319 const Int_t kmothervertexnumber = 12;
2320 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2321 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2322 ///////////////////////
2323 // Setting the vertices
2324 ///////////////////////
2325 xmothervertex[0][0] = -0.5*fgkSSDStiffenerLength;
2326 xmothervertex[0][1] = xmothervertex[0][0];
2327 xmothervertex[0][2] = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
2328 xmothervertex[0][3] = xmothervertex[0][2];
2329 xmothervertex[0][4] = xmothervertex[0][0];
2330 xmothervertex[0][5] = xmothervertex[0][4];
2331 xmothervertex[0][6] = -xmothervertex[0][0];
2332 xmothervertex[0][7] = xmothervertex[0][6];
2333 xmothervertex[0][8] = -xmothervertex[0][2];
2334 xmothervertex[0][9] = xmothervertex[0][8];
2335 xmothervertex[0][10] = xmothervertex[0][7];
2336 xmothervertex[0][11] = xmothervertex[0][10];
2337 for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
2338 for(Int_t i = 0; i<kmothernumber; i++){
2339 ymothervertex[i][0] = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
2340 + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
2341 ymothervertex[i][1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
2342 ymothervertex[i][2] = ymothervertex[i][1];
2343 ymothervertex[i][3] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
2344 ymothervertex[i][4] = ymothervertex[i][3];
2345 ymothervertex[i][5] = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
2346 ymothervertex[i][6] = ymothervertex[i][5];
2347 ymothervertex[i][7] = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
2348 ymothervertex[i][8] = ymothervertex[i][7];
2349 ymothervertex[i][9] = 0.5*fgkSSDStiffenerWidth;
2350 ymothervertex[i][10] = ymothervertex[i][9];
2351 ymothervertex[i][11] = ymothervertex[i][0];
2352 }
2353 TGeoXtru* ssdhybridmothershape[kmothernumber];
2354 TGeoVolume* ssdhybridmother[kmothernumber];
2355 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2356 for(Int_t i=0; i<kmothernumber; i++){
2357 ssdhybridmothershape[i] = new TGeoXtru(2);
2358 ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
2359 ymothervertex[i]);
2360 ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2361 -fgkSSDChipCablesHeight[i+2]);
2362 ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
2363 ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
2364 fSSDAir);
2365 }
2366 /////////////////////////////////////////////////////////////
2367 // SSD Stiffener
2368 /////////////////////////////////////////////////////////////
2369 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2370 0.5*fgkSSDStiffenerLength,
2371 0.5*fgkSSDStiffenerWidth,
2372 0.5*fgkSSDStiffenerHeight);
2373 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2374 fSSDStiffenerMedium);
2375 ssdstiffener->SetLineColor(fColorStiffener);
2376 TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
2377 for(Int_t i=0; i<kssdstiffenernumber; i++)
2378 ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
2379 /////////////////////////////////////////////////////////////
2380 // SSD Chip System
2381 /////////////////////////////////////////////////////////////
2382 TList* ssdchipsystemlist = GetSSDChipSystem();
2383 Double_t ssdchipseparation = fgkSSDSensorLength
2384 - 2.*fgkSSDModuleStiffenerPosition[1]
2385 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
2386 - 0.5*fgkSSDChipWidth);
2387 Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
2388 + fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
2389 TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
2390 - 0.5*ssdchipsystemlength,
2391 0.5*(ssdstiffenerseparation-ssdchipseparation),
2392 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
2393////////////////////////////
2394// Capacitor 0603-2200 nF
2395///////////////////////////
2396 const Int_t knapacitor0603number = 5;
2397 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
2398 0.5*fgkSSDCapacitor0603Length,
2399 0.5*fgkSSDCapacitor0603Width,
2400 0.5*fgkSSDCapacitor0603Height);
2401 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2402 fSSDStiffener0603CapacitorMedium);
2403 capacitor0603->SetLineColor(fColorAl);
bf210566 2404 for(Int_t i=0; i<kmothernumber; i++){
2405 for(Int_t j=0; j<kssdstiffenernumber; j++){
2406 ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
2407 for(Int_t k=1; k<knapacitor0603number+1; k++){
2408 ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
2409 new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
2410 j*ssdstiffenerseparation
2411 + 0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
2412 + (j==0? -1:+1)*fgkSSDCapacitor0603Width),
2413 - 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
2414 }
2415 }
2416 ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
2417 ssdhybridlist->Add(ssdhybridmother[i]);
2418 }
2419/////////////////////////////////////////////////////////////
2420// Mother Volume Containing Capacitor Part
2421/////////////////////////////////////////////////////////////
2422 const Int_t kcapacitormothernumber = 8;
2423 Double_t xcapacitorvertex[kcapacitormothernumber];
2424 Double_t ycapacitorvertex[kcapacitormothernumber];
2425 ///////////////////////
2426 // Setting the vertices
2427 ///////////////////////
2428 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2429 xcapacitorvertex[1] = xcapacitorvertex[0];
2430 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2431 xcapacitorvertex[3] = xcapacitorvertex[2];
2432 xcapacitorvertex[4] = xcapacitorvertex[0];
2433 xcapacitorvertex[5] = xcapacitorvertex[0];
2434 xcapacitorvertex[6] = -xcapacitorvertex[0];
2435 xcapacitorvertex[7] = xcapacitorvertex[6];
2436 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2437 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2438 ycapacitorvertex[2] = ycapacitorvertex[1];
2439 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2440 ycapacitorvertex[4] = ycapacitorvertex[3];
2441 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2442 ycapacitorvertex[6] = ycapacitorvertex[5];
2443 ycapacitorvertex[7] = ycapacitorvertex[0];
2444 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2445 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2446 ycapacitorvertex);
2447 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2448 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2449 TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2450 fSSDAir);
d7599219 2451////////////////////////////
bf210566 2452// Connector
d7599219 2453///////////////////////////
bf210566 2454 const Int_t kssdconnectornumber = 2;
2455 TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2456 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2457 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2458 + fgkSSDConnectorAlHeight};
2459 const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2460 TGeoVolume* ssdconnector[kssdconnectornumber];
2461 for(Int_t i=0; i<kssdconnectornumber; i++){
2462 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2463 0.5*fgkSSDConnectorWidth,
2464 0.5*((1-i)*fgkSSDConnectorAlHeight
2465 + i*fgkSSDConnectorNiHeight),
2466 i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2467 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2468 i==0 ? fSSDAlTraceFlexMedium
2469 : fSSDStiffenerConnectorMedium);
2470 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2471 }
2472 TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2473 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2474 + fgkSSDConnectorPosition[0]
2475 - fgkSSDConnectorSeparation
2476 - 1.5*fgkSSDConnectorLength,
2477 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2478 - fgkSSDConnectorPosition[1]
2479 - ssdconnectorshape[0]->GetDY(),0.0);
2480 ssdconnectortrans[1] = new TGeoTranslation(
2481 - ssdstiffenershape->GetDX()
2482 + fgkSSDConnectorPosition[0]
2483 - 0.5*fgkSSDConnectorLength,
2484 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2485 - fgkSSDConnectorPosition[1]
2486 - ssdconnectorshape[0]->GetDY(),0.0);
2487 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2488 - fgkSSDConnectorPosition[0]
2489 + fgkSSDConnectorSeparation
2490 + 1.5*fgkSSDConnectorLength,
2491 -(ssdstiffenershape->GetDY()
2492 - fgkSSDConnectorPosition[1]
2493 - ssdconnectorshape[0]->GetDY()),0.0);
2494 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2495 - fgkSSDConnectorPosition[0]
2496 + 0.5*fgkSSDConnectorLength,
2497 -(ssdstiffenershape->GetDY()
2498 - fgkSSDConnectorPosition[1]
2499 - ssdconnectorshape[0]->GetDY()),0.0);
2500 for(Int_t i=0; i<2*kssdconnectornumber; i++)
2501 for(Int_t j=0; j<kssdconnectornumber; j++)
2502 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2503////////////////////////////
2504// Capacitor 1812-330 nF
2505///////////////////////////
2506 Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2507 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2508 0.5*fgkSSDCapacitor1812Length,
2509 0.5*fgkSSDCapacitor1812Width,
bf210566 2510 0.5*fgkSSDCapacitor1812Height,
2511 ssdcapacitor1812origin);
44285dfa 2512 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2513 fSSDStiffener1812CapacitorMedium);
2514 capacitor1812->SetLineColor(fColorAl);
bf210566 2515 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2516 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2517 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2518 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
d7599219 2519////////////////////////////
2520//Hybrid Wire
2521////////////////////////////
44285dfa 2522 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2523 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2524 - fgkSSDConnectorSeparation;
44285dfa 2525 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2526 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
44285dfa 2527 Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
2528 + TMath::Power(wirey,2));
2529 Double_t wireangle = TMath::ATan(wirex/wirey);
2530 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2531 fgkSSDWireRadius, 0.5*ssdwireradius);
2532 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2533 fSSDStiffenerHybridWireMedium);
2534 hybridwire->SetLineColor(fColorPhynox);
2535 TGeoCombiTrans* hybridwirecombitrans[2];
2536 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2537 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2538 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2539 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2540 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2541 ssdstiffenershape->GetDZ()
2542 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
d7599219 2543 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2544 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2545 0.0,
2546 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2547 0.0,
2548 new TGeoRotation("HybridWireRot2",
2549 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2550 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2551 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2552 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2553 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2554 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2555 /////////////////////////////////////////////////////////////
bf210566 2556 // Deallocating memory
44285dfa 2557 /////////////////////////////////////////////////////////////
bf210566 2558 delete hybridwirecombitrans[0];
2559 delete hybridwirecombitrans[1];
2560 delete ssdchipsystemlist;
2561 return ssdhybridlist;
2562 /////////////////////////////////////////////////////////////
2563}
2564///////////////////////////////////////////////////////////////////////////////
2565TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2566 /////////////////////////////////////////////////////////////
2567 // SSD Cooling Block System
2568 /////////////////////////////////////////////////////////////
2569 // SSD Cooling Block and Cooling Tube Transformations
2570 /////////////////////////////////////////////////////////////
2571 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2572 localcoolingblockrot->SetAngles(0.,90.,0.);
535e8862 2573 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
bf210566 2574 TVector3* coolingblocktransvector;
2575 coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2576 + fgkSSDCoolingBlockLength,
2577 fgkSSDSensorLength
2578 - 2.*fgkSSDModuleStiffenerPosition[1]
2579 - fgkSSDCoolingBlockWidth);
2580 const Int_t kcoolingblocktransnumber = 2;
2581 const Int_t kcoolingblocknumber = 4;
2582 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2583 TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2584 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2585 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2586 TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2587 localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
535e8862 2588 0.5*fgkSSDCoolingBlockWidth,
2589 fgkSSDCoolingBlockHoleCenter);
2590 TGeoCombiTrans localcoolingtubematrix (*localcoolingtubetrans,*localcoolingtuberot);
bf210566 2591 Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2592 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
535e8862 2593 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2594 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X()+2*coolingtubedistance,
2595 j*coolingblocktransvector->Y(),
2596 - 0.5*(fgkSSDCoolingBlockHoleCenter
2597 + fgkCoolingTubeRmax));
2598 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
2599 coolingtubematrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingtubematrix);
2600 }
d7599219 2601 }
bf210566 2602 /////////////////////////////////////////////////////////////
2603 // Virtual Volume containing CoolingBlock System
2604 /////////////////////////////////////////////////////////////
2605 TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2606 const Int_t kmothervertexnumber = 16;
2607 Double_t xmothervertex[kmothervertexnumber];
2608 Double_t ymothervertex[kmothervertexnumber];
2609 ///////////////////////
2610 // Setting the vertices
2611 ///////////////////////fgkCoolingTubeSupportRmax
2612 xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2613 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2614 + fgkSSDCoolingBlockWidth;
2615 xmothervertex[2] = coolingblocktransvector->X()
2616 + fgkSSDCoolingBlockLength
2617 + 4*coolingtubedistance;
2618 ymothervertex[2] = ymothervertex[1];
2619 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2620 xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2621 ymothervertex[4] = ymothervertex[0];
2622 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2623 xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2624 ymothervertex[6] = ymothervertex[5];
2625 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2626 - fgkSSDCoolingBlockWidth;
2627 xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2628 xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2629 - coolingtubedistance;
2630 xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2631 ymothervertex[10] = ymothervertex[9];
2632 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2633 xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2634 xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2635 xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2636 ymothervertex[14] = ymothervertex[13];
2637 xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2638 //////////////////////////////////////////////////////////
2639 coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2640 xmothervertex,ymothervertex);
2641 coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2642 + fgkCoolingTubeRmax));
2643 coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2644 + fgkCoolingTubeRmax));
2645 TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
2646 coolingsystemothershape,fSSDAir);
2647 /////////////////////////////////////////////////////////////
2648 // SSD Cooling Tube Part
2649 /////////////////////////////////////////////////////////////
2650 TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
2651 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2652 0.5*fgkSSDCoolingBlockWidth);
2653 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
2654 0.5*fgkSSDCoolingBlockWidth);
2655 TGeoVolume* coolingtube[fgkcoolingtubenumber];
2656 coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
2657 fSSDCoolingTubePhynox);
2658 coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
2659 fSSDCoolingTubeWater);
2660 coolingtube[0]->SetLineColor(fColorPhynox);
2661 coolingtube[1]->SetLineColor(fColorWater);
2662 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2663 /////////////////////////////////////////////////////////////
2664 // Adding Cooling block to mother volume
2665 /////////////////////////////////////////////////////////////
2666 for(Int_t i=0; i<kcoolingblocknumber; i++){
2667 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2668 coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
2669 coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
d7599219 2670 }
bf210566 2671 /////////////////////////////////////////////////////////////
2672 // Deallocating memory
2673 /////////////////////////////////////////////////////////////
2674 delete coolingblocktransvector;
bf210566 2675 delete localcoolingblockrot;
bf210566 2676 delete localcoolingtubetrans;
2677 delete localcoolingtuberot;
2678 /////////////////////////////////////////////////////////////
2679 // Checking overlaps
2680 /////////////////////////////////////////////////////////////
6727e2db 2681 //coolingsystemother->CheckOverlaps(0.01);
bf210566 2682 /////////////////////////////////////////////////////////////
2683 return coolingsystemother;
d7599219 2684}
2685/////////////////////////////////////////////////////////////////////////////////
bf210566 2686TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2687 /////////////////////////////////////////////////////////////
bf210566 2688 // SSD Flex
44285dfa 2689 /////////////////////////////////////////////////////////////
bf210566 2690 const Int_t kssdflexlayernumber = 2;
2691 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2692 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2693 const Int_t kmothervertexnumber = 17;
2694 Double_t xmothervertex[kmothervertexnumber];
2695 Double_t ymothervertex[kmothervertexnumber];
2696 /////////////////////////////////////////////
2697 // Auxiliary variables for vertex positioning
2698 /////////////////////////////////////////////
2699 const Int_t kssdflexboxnumber = 5;
44285dfa 2700 Double_t ssdflexboxlength[kssdflexboxnumber];
2701 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2702 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2703 * fgkSSDChipSeparationLength
2704 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2705 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2706 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2707 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2708 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2709 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2710 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2711 - ssdflexboxlength[1];
44285dfa 2712 Double_t ssdflexboxwidth[kssdflexboxnumber];
2713 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2714 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2715 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2716 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2717 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2718 ///////////////////////
2719 // Setting the vertices
2720 ///////////////////////
2721 xmothervertex[0] = 0.0;
2722 xmothervertex[1] = xmothervertex[0];
2723 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2724 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2725 + ssdflexboxlength[4];
2726 xmothervertex[4] = xmothervertex[3];
2727 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2728 xmothervertex[6] = xmothervertex[5];
2729 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2730 xmothervertex[8] = xmothervertex[7];
2731 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2732 xmothervertex[10] = xmothervertex[9];
2733 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2734 xmothervertex[12] = xmothervertex[11];
2735 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2736 xmothervertex[14] = xmothervertex[13];
2737 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2738 xmothervertex[16] = xmothervertex[15];
2739 ymothervertex[0] = 0.0;
2740 ymothervertex[1] = fgkSSDFlexWidth[1];
2741 ymothervertex[2] = fgkSSDFlexWidth[0];
2742 ymothervertex[3] = ymothervertex[2];
2743 ymothervertex[4] = ymothervertex[0];
2744 ymothervertex[5] = ymothervertex[4];
2745 ymothervertex[6] = ssdflexboxwidth[2];
2746 ymothervertex[7] = ymothervertex[6];
2747 ymothervertex[8] = ymothervertex[0];
2748 ymothervertex[9] = ymothervertex[8];
2749 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2750 ymothervertex[11] = ymothervertex[10];
2751 ymothervertex[12] = ymothervertex[0];
2752 ymothervertex[13] = ymothervertex[12];
2753 ymothervertex[14] = ymothervertex[7];
2754 ymothervertex[15] = ymothervertex[14];
2755 ymothervertex[16] = ymothervertex[0];
2756 /////////////////////////////////////////////////////////////
2757 // First Mother Volume containing SSDFlex
2758 /////////////////////////////////////////////////////////////
2759 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2760 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2761 ymothervertex);
2762 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2763 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2764 TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2765 fSSDAir);
2766 /////////////////////////////////////////////////////////////
2767 // SSDFlex Layer Shapes
2768 /////////////////////////////////////////////////////////////
2769 for(Int_t i=0; i<kssdflexlayernumber; i++){
2770 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2771 ymothervertex);
2772 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2773 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2774 }
2775 /////////////////////////////////////
2776 // Setting Layers into Mother Volume
2777 /////////////////////////////////////
2778 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2779 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2780 fSSDKaptonFlexMedium};
2781 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2782 "AlFlexLay2","KaptonFlexLay2"};
2783 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2784 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2785 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2786 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2787 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2788 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2789 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2790 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2791 + fgkSSDFlexHeight[1]));
2792 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2793 }
6727e2db 2794 //ssdflexmother->CheckOverlaps(0.01);
bf210566 2795 return ssdflexmother;
d7599219 2796}
2797/////////////////////////////////////////////////////////////////////////////////
bf210566 2798TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2799 /////////////////////////////////////////////////////////////
2800 // Method generating SSD End Flex
d7599219 2801 /////////////////////////////////////////
bf210566 2802 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2803 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2804 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2805 * TMath::DegToRad()*ssdflexradiusmax
2806 - fgkSSDFlexLength[2]-TMath::Pi()
2807 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
2808 const Int_t knedges = 20;
2809 const Int_t karcnumber = 2;
2810 TVector3* vertexposition[karcnumber*(knedges+1)];
2811 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2812 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2813 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2814 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2815 - 90.0*TMath::DegToRad()};
2816 TVector3* referencetrans[karcnumber];
2817 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2818 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2819 radius[0]);
2820 referencetrans[1] = new TVector3(referencetrans[0]->X()
2821 + fgkSSDFlexLength[2],
2822 - fgkSSDStiffenerHeight);
2823for(Int_t i=0; i<karcnumber; i++){
2824 for(Int_t j=0; j<knedges+1; j++){
2825 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2826 radius[i]*SinD(angle[i]));
2827 angle[i] += deltangle[i]*(1.0-2.0*i);
2828 }
2829 }
2830 ///////////////////////
2831 // Setting the vertices
2832 ///////////////////////
2833 const Int_t kendflexlayernumber = 4;
2834 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2835 TVector3** vertex[kendflexlayernumber];
2836 for(Int_t i=0; i<kendflexlayernumber; i++)
2837 vertex[i] = new TVector3*[kendflexvertexnumber];
2838 TVector3* transvector[kendflexlayernumber+1];
2839 TVector3* deltatransvector = new TVector3();
2840 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2841 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2842 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2843 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2844 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2845 * CosD(fgkSSDFlexAngle),
2846 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2847 * SinD(fgkSSDFlexAngle),0.0);
2848 *transvector[i] = *transvector[i-1]+*deltatransvector;
2849 }
2850 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2851 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2852 for(Int_t i=0; i<karcnumber; i++){
2853 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2854 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2855 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2856 /radius[i];
2857 }
2858 }
2859 for(Int_t i=0; i<kendflexlayernumber; i++){
2860 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2861 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2862 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2863 if(j<(knedges+1)){
2864 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2865 vertexposition[j]->Y()*ratioradius[0][i+1]);
2866 vertex[i][j+2]->RotateZ(referenceangle[0]);
2867 *vertex[i][j+2] += *referencetrans[0];
2868 vertex[i][4*(knedges+1)-j+1] =
2869 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2870 vertexposition[j]->Y()*ratioradius[0][i]);
2871 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2872 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2873 }
2874 else{
2875
2876 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2877 vertexposition[j]->Y()*ratioradius[1][i+1]);
2878 vertex[i][j+2]->RotateZ(referenceangle[1]);
2879 *vertex[i][j+2] += *referencetrans[1];
2880 vertex[i][4*(knedges+1)-j+1] =
2881 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2882 vertexposition[j]->Y()*ratioradius[1][i]);
2883 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2884 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2885 }
2886 }
2887 }
44285dfa 2888 /////////////////////////////////////////////////////////////
bf210566 2889 // First Mother Volume containing SSDEndFlex
2890 /////////////////////////////////////////////////////////////
2891 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2892 Double_t xmothervertex[kendflexvertexnumber];
2893 Double_t ymothervertex[kendflexvertexnumber];
2894 xmothervertex[0] = vertex[0][0]->X();
2895 ymothervertex[0] = vertex[0][0]->Y();
2896 for(Int_t i=1; i<kendflexvertexnumber; i++){
2897 if(i<2*(knedges+1)+2){
2898 xmothervertex[i] = vertex[3][i]->X();
2899 ymothervertex[i] = vertex[3][i]->Y();
2900 }
2901 else{
2902 xmothervertex[i] = vertex[0][i]->X();
2903 ymothervertex[i] = vertex[0][i]->Y();
2904 }
2905 }
2906 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2907 xmothervertex,ymothervertex);
2908 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2909 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2910 TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2911 ssdendflexmothershape,fSSDAir);
2912 //////////////////////////////////////
2913 // End Flex TGeoXtru Layer Definition
2914 //////////////////////////////////////
2915 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2916 TGeoVolume* ssdendflex[kendflexlayernumber];
2917 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2918 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2919 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2920 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2921 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2922 fSSDKaptonFlexMedium};
2923 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2924 "AlEndFlexLay2","KaptonEndFlexLay2"};
2925 for(Int_t i=0; i<kendflexlayernumber; i++){
2926 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2927 xvertex[i][j] = vertex[i][j]->X();
2928 yvertex[i][j] = vertex[i][j]->Y();
2929 }
2930 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2931 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2932 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2933 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2934 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2935 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2936 ssdendflexmother->AddNode(ssdendflex[i],1);
2937 }
44285dfa 2938 /////////////////////////////////////////////////////////////
bf210566 2939 // Deallocating memory
44285dfa 2940 /////////////////////////////////////////////////////////////
bf210566 2941 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2942 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2943 for(Int_t i=0; i<kendflexlayernumber; i++){
2944 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2945 delete [] vertex[i];
2946 }
2947 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2948 delete deltatransvector;
44285dfa 2949 /////////////////////////////////////////////////////////////
6727e2db 2950 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 2951 return ssdendflexmother;
d7599219 2952}
9b0c60ab 2953///////////////////////////////////////////////////////////////////////////////
bf210566 2954TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 2955 /////////////////////////////////////////////////////////////
9b0c60ab 2956 // Method generating the Mounting Block
bf210566 2957 /////////////////////////////////////////////////////////////
9b0c60ab 2958 const Int_t kvertexnumber = 8;
2959 Double_t xvertex[kvertexnumber];
2960 Double_t yvertex[kvertexnumber];
2961 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2962 xvertex[1] = xvertex[0];
2963 xvertex[2] = -xvertex[0];
2964 xvertex[3] = xvertex[2];
2965 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2966 - fgkSSDMountingBlockLength[2]);
2967 xvertex[5] = xvertex[4];
2968 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2969 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2970 - fgkSSDMountingBlockScrewHoleRadius[0];
2971 xvertex[7] = xvertex[6];
2972 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
e21cdd03 2973 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]
2974 - fgkSSDModuleVerticalDisalignment;
9b0c60ab 2975 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2976 yvertex[2] = yvertex[1];
2977 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2978 yvertex[4] = yvertex[3];
2979 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2980 - fgkSSDMountingBlockHeight[0];
2981 yvertex[6] = yvertex[5];
2982 yvertex[7] = yvertex[0];
2983 ///////////////////////////////////////////////////////////////////////
2984 // TGeoXTru Volume definition for Mounting Block Part
2985 ///////////////////////////////////////////////////////////////////////
2986 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2987 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2988 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2989 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 2990 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 2991 ssdmountingblockshape,
2992 fSSDMountingBlockMedium);
2993 ssdmountingblock->SetLineColor(fColorG10);
2994 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2995 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2996 TGeoRotation* mountingblockrot = new TGeoRotation();
2997 mountingblockrot->SetAngles(90.,180.,-90.);
2998 mountingblockcombitrans->SetRotation(*mountingblockrot);
2999 /////////////////////////////////////////////////////////////
3000 // Generating the Mounting Block Screw Vertices
3001 /////////////////////////////////////////////////////////////
3002 const Int_t kscrewvertexnumber = 15;
3003 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
3004 - fgkSSDMountingBlockScrewHoleEdge)
3005 / fgkSSDMountingBlockScrewHoleRadius[0])
3006 * TMath::RadToDeg();
3007 Double_t phi0 = 90.+alpha;
3008 Double_t phi = 270.-2*alpha;
3009 Double_t deltaphi = phi/kscrewvertexnumber;
3010 TVector3* screwvertex[kscrewvertexnumber+1];
3011 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
3012 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
3013 *CosD(phi0+i*deltaphi),
3014 fgkSSDMountingBlockScrewHoleRadius[0]
3015 *SinD(phi0+i*deltaphi));
3016 Double_t xscrewvertex[kscrewvertexnumber+6];
3017 Double_t yscrewvertex[kscrewvertexnumber+6];
3018 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
3019 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
3020 - fgkSSDMountingBlockScrewHoleEdge);
3021 xscrewvertex[1] = xscrewvertex[0];
3022 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3023 xscrewvertex[2] = screwvertex[0]->X();
3024 yscrewvertex[2] = yscrewvertex[1];
3025 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
3026 xscrewvertex[i+3] = screwvertex[i]->X();
3027 yscrewvertex[i+3] = screwvertex[i]->Y();
3028 }
3029 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3030 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
3031 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
3032 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
3033 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
3034 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
3035 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
3036 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
3037 + fgkSSDMountingBlockHeight[2]);
3038 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
3039 ssdmountingblockscrewshape,
3040 fSSDMountingBlockMedium);
3041 ssdmountingblockscrew->SetLineColor(fColorG10);
3042 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
3043 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
3044 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3045 - yscrewvertex[1],
3046 0.5*fgkSSDMountingBlockHeight[0]
3047 - fgkSSDMountingBlockHeight[2]
3048 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3049 + fgkSSDMountingBlockHeight[2]
3050 - yvertex[0]));
3051 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3052 -0.5*fgkSSDMountingBlockScrewHoleEdge,
3053 yscrewvertex[1]
3054 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3055 +fgkSSDMountingBlockHeight[2]
3056 -yvertex[0]));
3057 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3058 yscrewvertex[1],
3059 - 0.5*fgkSSDMountingBlockHeight[0]
3060 + fgkSSDMountingBlockHeight[2]
3061 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3062 + fgkSSDMountingBlockHeight[2]
3063 - yvertex[0]));
3064 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3065 yscrewvertex[1],
3066 - yscrewvertex[1]
3067 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3068 + fgkSSDMountingBlockHeight[2]
3069 - yvertex[0]));
3070 TGeoRotation* ssdmountingblockscrewrot[4];
3071 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3072 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3073 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3074 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3075 for(Int_t i=1; i<4; i++)
3076 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3077 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3078 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3079 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3080 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3081 + xvertex[0],yscrewvertex[1]
3082 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3083 + fgkSSDMountingBlockHeight[2]
3084 - yvertex[0]),0.);
3085 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3086 for(Int_t i=0; i<4; i++){
3087 ssdmountingblockscrewmatrix[i] =
3088 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3089 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3090 }
3091 ///////////////////////////////////////////////////////////////////////
3092 // TGeoXtru for Mother Volume
3093 ///////////////////////////////////////////////////////////////////////
3094 const Int_t kvertexmothernumber = 12;
3095 Double_t xmothervertex[kvertexmothernumber];
3096 Double_t ymothervertex[kvertexmothernumber];
3097 for(Int_t i=0; i<6; i++){
3098 xmothervertex[i] = xvertex[i];
3099 ymothervertex[i] = yvertex[i];
3100 }
3101 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3102 ymothervertex[6] = ymothervertex[5];
3103 xmothervertex[7] = xmothervertex[6];
3104 ymothervertex[7] = ymothervertex[4];
3105 xmothervertex[8] = xmothervertex[7]
3106 + 0.5*(fgkSSDMountingBlockLength[1]
3107 - fgkSSDMountingBlockLength[2]);
3108 ymothervertex[8] = ymothervertex[4];
3109 xmothervertex[9] = xmothervertex[8];
3110 ymothervertex[9] = ymothervertex[2];
3111 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3112 ymothervertex[10] = ymothervertex[1];
3113 xmothervertex[11] = xmothervertex[10];
3114 ymothervertex[11] = ymothervertex[0];
3115 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3116 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3117 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3118 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3119 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3120 ssdmountingblockmothershape,
3121 fSSDAir);
3122 /////////////////////////////////////////////////////////////
3123 // Placing the Volumes into Mother Volume
3124 /////////////////////////////////////////////////////////////
3125 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3126 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3127 for(Int_t i=0; i<4; i++)
3128 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3129 ssdmountingblockscrewmatrix[i]);
3130 /////////////////////////////////////////////////////////////
3131 // Deallocating memory
3132 /////////////////////////////////////////////////////////////
3133 delete mountingblockrot;
3134 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3135 delete ssdmountingblockglobalrot;
3136 delete ssdmountingblockglobaltrans;
3137 /////////////////////////////////////////////////////////////
3138 return ssdmountingblockmother;
3139}
3140///////////////////////////////////////////////////////////////////////////////
3141 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3142 /////////////////////////////////////////////////////////////
3143 // Method generating the Mounting Block Clip
3144 /////////////////////////////////////////////////////////////
3145 const Int_t kmothervertexnumber = 10;
3146 Double_t xmothervertex[kmothervertexnumber];
3147 Double_t ymothervertex[kmothervertexnumber];
3148 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3149 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3150 xmothervertex[1] = xmothervertex[0];
3151 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3152 - fgkMountingBlockClibScrewRadius);
3153 xmothervertex[3] = xmothervertex[2];
3154 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3155 xmothervertex[5] = xmothervertex[4];
3156 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3157 xmothervertex[7] = xmothervertex[6];
3158 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3159 xmothervertex[9] = xmothervertex[8];
3160 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
e21cdd03 3161 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]
3162 - fgkSSDModuleVerticalDisalignment;
9b0c60ab 3163 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3164 ymothervertex[2] = ymothervertex[1];
3165 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3166 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3167 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3168 ymothervertex[4] = ymothervertex[3];
3169 ymothervertex[5] = ymothervertex[2];
3170 ymothervertex[6] = ymothervertex[5];
3171 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3172 ymothervertex[8] = ymothervertex[7];
3173 ymothervertex[9] = ymothervertex[0];
3174 ///////////////////////////////////////////////////////////////////////
3175 // TGeoXTru Volume definition for Mounting Block Clip Part
3176 ///////////////////////////////////////////////////////////////////////
3177 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3178 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3179 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3180 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3181 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3182 ssdmountingblockclipshape,fSSDAir);
3183 ssdmountingblockclip->SetLineColor(4);
3184 ///////////////////////////////////////////////////////////////////////
3185 // TGeoXTru Volume definition for Clip
3186 ///////////////////////////////////////////////////////////////////////
3187 const Int_t kclipvertexnumber = 6;
3188 Double_t xclipvertex[kclipvertexnumber];
3189 Double_t yclipvertex[kclipvertexnumber];
3190 xclipvertex[0] = xmothervertex[0];
3191 xclipvertex[1] = xclipvertex[0];
3192 xclipvertex[2] = xmothervertex[6];
3193 xclipvertex[3] = xclipvertex[2];
3194 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3195 xclipvertex[5] = xclipvertex[4];
3196 yclipvertex[0] = ymothervertex[0];
3197 yclipvertex[1] = ymothervertex[1];
3198 yclipvertex[2] = yclipvertex[1];
3199 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3200 yclipvertex[4] = yclipvertex[3];
3201 yclipvertex[5] = yclipvertex[0];
3202 TGeoXtru* clipshape = new TGeoXtru(2);
3203 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3204 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3205 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3206 + fgkMountingBlockClibWidth);
3207 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3208 clip->SetLineColor(18);
3209 ///////////////////////////////////////////////////////////////////////
3210 // Ladder Support Piece
3211 ///////////////////////////////////////////////////////////////////////
3212 const Int_t ksupportvertexnumber = 4;
3213 Double_t xsupportvertex[ksupportvertexnumber];
3214 Double_t ysupportvertex[ksupportvertexnumber];
3215 xsupportvertex[0] = xclipvertex[5];
3216 xsupportvertex[1] = xsupportvertex[0];
3217 xsupportvertex[2] = xmothervertex[9];
3218 xsupportvertex[3] = xsupportvertex[2];
3219 ysupportvertex[0] = yclipvertex[0];
3220 ysupportvertex[1] = yclipvertex[3];
3221 ysupportvertex[2] = ysupportvertex[1];
3222 ysupportvertex[3] = ysupportvertex[0];
3223 TGeoXtru* supportshape = new TGeoXtru(2);
3224 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3225 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3226 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3227 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3228 support->SetLineColor(9);
3229 ///////////////////////////////////////////////////////////////////////
3230 // TGeoXTru Volume definition for Screw
3231 ///////////////////////////////////////////////////////////////////////
3232 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3233 0.5*fgkMountingBlockClibScrewRadius};
3234 Int_t edgesnumber[2] = {50,6};
3235 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3236 +0.5*(ymothervertex[3]-ymothervertex[2])};
3237 TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3238 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3239 clipscrew->SetLineColor(12);
3240 TGeoRotation* screwrot = new TGeoRotation();
3241 screwrot->SetAngles(0.,90.,0.);
3242 TGeoTranslation* screwtrans = new TGeoTranslation();
3243 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3244 0.5*(ymothervertex[3]+ymothervertex[2]),
3245 0.5*fgkSSDMountingBlockWidth+
3246 -0.5*fgkMountingBlockSupportWidth[0]);
3247 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3248 ///////////////////////////////////////////////////////////////////////
3249 // Placing the Volumes
3250 ///////////////////////////////////////////////////////////////////////
3251 ssdmountingblockclip->AddNode(clip,1);
3252 ssdmountingblockclip->AddNode(support,1);
3253 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3254 /////////////////////////////////////////////////////////////
3255 // Deallocating memory
3256 /////////////////////////////////////////////////////////////
3257 delete screwtrans;
3258 delete screwrot;
3259 /////////////////////////////////////////////////////////////
3260 return ssdmountingblockclip;
d7599219 3261}
bf210566 3262///////////////////////////////////////////////////////////////////////////////
3263TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
44285dfa 3264 /////////////////////////////////////////////////////////////
bf210566 3265 // Method generating the Cooling Tube
44285dfa 3266 /////////////////////////////////////////////////////////////
bf210566 3267 TGeoTube** coolingtubeshape[fgkcoolingtubenumber];
3268 for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtubeshape[i] =
3269 new TGeoTube*[2];
9b0c60ab 3270 // Ladder Cooling Tubes
bf210566 3271 coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3272 0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3273 - 2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth));
3274 coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3275 coolingtubeshape[0][0]->GetDz());
3276 coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3277 0.5*(fgkSSDModuleStiffenerPosition[1]
3278 - fgkSSDSensorOverlap));
3279 coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3280 coolingtubeshape[1][0]->GetDz());
3281 coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3282 0.5*fgkSSDModuleStiffenerPosition[1]);
3283 coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3284 coolingtubeshape[2][0]->GetDz());
9b0c60ab 3285 // End Ladder Cooling Tubes
3286 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3287 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3288 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3289 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3290 0.50 * (fgkEndLadderMountingBlockPosition[0]
3291 - fgkendladdercoolingsupportdistance[0]));
3292 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3293 endladdercoolingtubeshape[0][0]->GetDz());
3294 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3295 0.50 * (fgkendladdercoolingsupportdistance[0]
3296 + fgkendladdercoolingsupportdistance[1]
3297 - fgkCoolingTubeSupportWidth));
3298 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3299 endladdercoolingtubeshape[1][0]->GetDz());
3300 endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3301 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
3302 - fgkEndLadderMountingBlockPosition[0]
3303 - fgkendladdercoolingsupportdistance[1]
3304 - fgkCoolingTubeSupportWidth));
3305 endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3306 endladdercoolingtubeshape[2][0]->GetDz());
3307 endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3308 0.50 * (fgkMountingBlockToSensorSupport
3309 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
3310 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
3311 + fgkSSDSensorOverlap
3312 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
3313 - fgkendladdercoolingsupportdistance[2]
3314 - fgkEndLadderMountingBlockPosition[1]
3315 - fgkCoolingTubeSupportWidth));
3316 endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3317 endladdercoolingtubeshape[3][0]->GetDz());
3318 endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3319 0.50 * fgkendladdercoolingsupportdistance[2]);
3320 endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3321 endladdercoolingtubeshape[4][0]->GetDz());
3322 // Ladder Cooling Tubes
bf210566 3323 TGeoVolume** coolingtube[fgkcoolingtubenumber];
3324 for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtube[i] =
3325 new TGeoVolume*[2];
3326 coolingtube[0][0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0][0],
3327 fSSDCoolingTubePhynox);
3328 coolingtube[0][1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[0][1],
3329 fSSDCoolingTubeWater);
3330 coolingtube[1][0] = new TGeoVolume("OuterCoolingTube2",coolingtubeshape[1][0],
3331 fSSDCoolingTubePhynox);
3332 coolingtube[1][1] = new TGeoVolume("InnerCoolingTube2",coolingtubeshape[1][1],
3333 fSSDCoolingTubeWater);
3334 coolingtube[2][0] = new TGeoVolume("OuterCoolingTube3",coolingtubeshape[2][0],
3335 fSSDCoolingTubePhynox);
3336 coolingtube[2][1] = new TGeoVolume("InnerCoolingTube3",coolingtubeshape[2][1],
3337 fSSDCoolingTubeWater);
3338 for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3339 coolingtube[i][0]->SetLineColor(fColorPhynox);
3340 coolingtube[i][1]->SetLineColor(fColorWater);
3341 }
9b0c60ab 3342 // End Ladder Cooling Tubes
3343 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3344 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3345 endladdercoolingtube[i] = new TGeoVolume*[2];
3346 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3347 endladdercoolingtubeshape[0][0],
3348 fSSDCoolingTubePhynox);
3349 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3350 endladdercoolingtubeshape[0][1],
3351 fSSDCoolingTubeWater);
3352 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3353 endladdercoolingtubeshape[1][0],
3354 fSSDCoolingTubePhynox);
3355 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3356 endladdercoolingtubeshape[1][1],
3357 fSSDCoolingTubeWater);
3358 endladdercoolingtube[2][0] = new TGeoVolume("OuterEndLadderCoolingTube3",
3359 endladdercoolingtubeshape[2][0],
3360 fSSDCoolingTubePhynox);
3361 endladdercoolingtube[2][1] = new TGeoVolume("InnerEndlLadderCoolingTube3",
3362 endladdercoolingtubeshape[2][1],
3363 fSSDCoolingTubeWater);
3364 endladdercoolingtube[3][0] = new TGeoVolume("OuterEndLadderCoolingTube4",
3365 endladdercoolingtubeshape[3][0],
3366 fSSDCoolingTubePhynox);
3367 endladdercoolingtube[3][1] = new TGeoVolume("InnerEndlLadderCoolingTube4",
3368 endladdercoolingtubeshape[3][1],
3369 fSSDCoolingTubeWater);
3370 endladdercoolingtube[4][0] = new TGeoVolume("OuterEndLadderCoolingTube5",
3371 endladdercoolingtubeshape[4][0],
3372 fSSDCoolingTubePhynox);
3373 endladdercoolingtube[4][1] = new TGeoVolume("InnerEndlLadderCoolingTube5",
3374 endladdercoolingtubeshape[4][1],
3375 fSSDCoolingTubeWater);
3376 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3377 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3378 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3379 }
bf210566 3380 /////////////////////////////////////////////////////////////
3381 // Virtual Volume containing Cooling Tubes
3382 /////////////////////////////////////////////////////////////
9b0c60ab 3383 // Ladder Cooling Tubes
bf210566 3384 TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber];
3385 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
3386 virtualcoolingtubeshape[i] = new TGeoTube(coolingtubeshape[i][1]->GetRmin(),
3387 coolingtubeshape[i][0]->GetRmax(),
3388 coolingtubeshape[i][0]->GetDz());
3389 TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber];
3390 virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0],
3391 fSSDAir);
3392 virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1],
3393 fSSDAir);
3394 virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2],
3395 fSSDAir);
9b0c60ab 3396 // End Ladder Cooling Tubes
3397 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3398 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3399 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3400 endladdercoolingtubeshape[i][0]->GetRmax(),
3401 endladdercoolingtubeshape[i][0]->GetDz());
3402 TGeoVolume* endladdervirtualcoolingtube[fgkendladdercoolingtubenumber];
3403 endladdervirtualcoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3404 endladdervirtualcoolingtubeshape[0],
3405 fSSDAir);
3406 endladdervirtualcoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3407 endladdervirtualcoolingtubeshape[1],
3408 fSSDAir);
3409 endladdervirtualcoolingtube[2] = new TGeoVolume("EndLadderCoolingTube3",
3410 endladdervirtualcoolingtubeshape[2],
3411 fSSDAir);
3412 endladdervirtualcoolingtube[3] = new TGeoVolume("EndLadderCoolingTube4",
3413 endladdervirtualcoolingtubeshape[3],
3414 fSSDAir);
3415 endladdervirtualcoolingtube[4] = new TGeoVolume("EndLadderCoolingTube5",
3416 endladdervirtualcoolingtubeshape[4],
3417 fSSDAir);
bf210566 3418 TList* coolingtubelist = new TList();
3419 for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3420 virtualcoolingtube[i]->AddNode(coolingtube[i][0],1);
3421 virtualcoolingtube[i]->AddNode(coolingtube[i][1],1);
3422 coolingtubelist->Add(virtualcoolingtube[i]);
d7599219 3423 }
9b0c60ab 3424 endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3425 endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3426 coolingtubelist->Add(endladdervirtualcoolingtube[0]);
3427 endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3428 endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3429 coolingtubelist->Add(endladdervirtualcoolingtube[1]);
3430 endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][0],1);
3431 endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][1],1);
3432 coolingtubelist->Add(endladdervirtualcoolingtube[2]);
3433 endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][0],1);
3434 endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][1],1);
3435 coolingtubelist->Add(endladdervirtualcoolingtube[3]);
3436 endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][0],1);
3437 endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][1],1);
3438 coolingtubelist->Add(endladdervirtualcoolingtube[4]);
bf210566 3439 return coolingtubelist;
d7599219 3440}
bf210566 3441///////////////////////////////////////////////////////////////////////////////
3442TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3443 /////////////////////////////////////////////////////////////
bf210566 3444 // Method generating SSD Cooling Block
44285dfa 3445 /////////////////////////////////////////////////////////////
bf210566 3446 const Int_t kvertexnumber = 8;
3447 ///////////////////////////////////////
3448 // Vertex Positioning for TGeoXTru
3449 ///////////////////////////////////////
3450 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3451 vertexposition[0] = new TVector3(0.0,0.0);
3452 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3453 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3454 vertexposition[1]->Y());
3455 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3456 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3457 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3458 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3459 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3460 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3461 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3462 - fgkSSDCoolingBlockHoleLength[0]
3463 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3464 fgkSSDCoolingBlockHeight[0]
3465 - fgkSSDCoolingBlockHoleRadius[1],
3466 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3467 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3468 - fgkSSDCoolingBlockHoleLength[0]),
3469 vertexposition[6]->Y());
3470 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3471 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3472 Double_t phi = 180.-alpha;
3473 Double_t psi = 180.+2.*alpha;
3474 Double_t deltapsi = psi/nedges;
3475 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3476 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3477 fgkSSDCoolingBlockHoleCenter);
3478 for(Int_t i=0; i<nedges+1; i++){
3479 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3480 radius*SinD(phi+i*deltapsi));
3481 *vertexposition[kvertexnumber+i] += (*transvector);
3482 }
3483 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3484 for(Int_t i=0; i<kvertexnumber; i++)
3485 vertexposition[kvertexnumber+nedges+1+i] =
3486 GetReflection(vertexposition[kvertexnumber-1-i],param);
3487 ///////////////////////////////////////////////////////////////////////
3488 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3489 ///////////////////////////////////////////////////////////////////////
3490 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3491 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3492 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3493 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3494 xvertexpoints[i] = vertexposition[i]->X();
3495 yvertexpoints[i] = vertexposition[i]->Y();
3496 }
3497 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3498 yvertexpoints);
3499 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3500 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3501 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3502 ssdcoolingblockshape,
3503 fSSDAlCoolBlockMedium);
3504 ssdcoolingblock->SetLineColor(fColorAl);
3505 /////////////////////////////////////////////////////////////
3506 // Deallocating memory
3507 /////////////////////////////////////////////////////////////
3508 delete [] vertexposition;
3509 delete xvertexpoints;
3510 delete yvertexpoints;
3511 /////////////////////////////////////////////////////////////
3512 return ssdcoolingblock;
3513}
3514/////////////////////////////////////////////////////////////////////////////////
3515TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
d7599219 3516 ///////////////////////////////////////////////////////
bf210566 3517 const Int_t kssdchipcablesnumber = 2;
3518 const Int_t kssdchipcableslaynumber = 2;
3519 const Int_t kvertexnumber = 4*(nedges+1)+4;
3520 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3521 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3522 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
3523 - fgkSSDChipCablesHeight[0]
3524 - fgkSSDChipCablesHeight[1]);
3525 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3526 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3527 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3528 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3529 - ssdchipcablesradius[0]
3530 - fgkSSDChipCablesWidth[1]
3531 - fgkSSDChipCablesWidth[2]);
3532 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3533 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3534 + fgkSSDChipCablesHeight[1]
3535 + fgkSSDSensorHeight);
d7599219 3536 ///////////////////////////////////////////////////////
bf210566 3537 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3538 ///////////////////////////////////////////////////////
3539 TVector3** vertexposition[kssdchipcableslaynumber];
3540 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3541 new TVector3*[4*(nedges+1)+4];
3542 Double_t ratio[4];
3543 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3544 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3545 / ssdchipcablesradius[0];
3546 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3547 / ssdchipcablesradius[0];
3548 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3549 + fgkSSDChipCablesHeight[1])
3550 / ssdchipcablesradius[0];
3551 Double_t phi = 180.;
3552 Double_t deltaphi = 180./nedges;
3553 Double_t angle = 0.0;
3554 Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3555 Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3556 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3557 xvertexpoints[i] = new Double_t[kvertexnumber];
3558 yvertexpoints[i] = new Double_t[kvertexnumber];
3559 }
3560 TVector3* vertex = new TVector3();
3561 TVector3* transvector[kssdchipcableslaynumber];
3562 transvector[0] = new TVector3(fgkSSDChipWidth,
3563 SSDChipCablesHeigth-ssdchipcablesradius[0]);
3564 transvector[1] = new TVector3();
3565 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
3566 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
3567 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
3568 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3569 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3570 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3571 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3572 transvector[1]->SetY(ssdchipcablesradius[0]
3573 + fgkSSDChipCablesHeight[0]
3574 + fgkSSDChipCablesHeight[1]);
3575 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3576 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
3577 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
3578 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
3579 - i*fgkSSDChipCablesHeight[0]);
3580 vertexposition[i][2*(nedges+1)+2] =
3581 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3582 + fgkSSDChipCablesWidth[1]
3583 + fgkSSDChipCablesWidth[2],
3584 ((1.-i)*fgkSSDChipCablesHeight[i]
3585 + fgkSSDChipCablesHeight[1]));
3586 vertexposition[i][2*(nedges+1)+3] =
3587 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3588 vertexposition[i][2*(nedges+1)+2]->Y()
3589 - fgkSSDChipCablesHeight[i]);
3590 for(Int_t j=0; j<nedges+1; j++){
3591 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3592 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3593 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3594 vertexposition[0][(nedges+1)*i+j+2] =
3595 new TVector3(*vertex+*transvector[i]);
3596 vertexposition[1][(nedges+1)*i+j+2] =
3597 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3598 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3599 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3600 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3601 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3602 new TVector3(vertex->X()*ratio[2*i+1]
3603 + transvector[i]->X(),
3604 vertex->Y()*ratio[2*i+1]
3605 + transvector[i]->Y());
3606 }
3607 }
3608 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3609 for(Int_t j=0; j<kvertexnumber; j++){
3610 xvertexpoints[i][j] = vertexposition[i][j]->X();
3611 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3612 }
3613 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3614 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3615 xvertexpoints[i],yvertexpoints[i]);
3616 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3617 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3618 ssdchipcable[kssdchipcablesnumber*k+i] =
3619 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3620 ssdchipcableshape[kssdchipcablesnumber*k+i],
3621 (kssdchipcablesnumber*k+i)%2==0?
3622 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3623 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3624 }
3625 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3626 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3627 }
44285dfa 3628 /////////////////////////////////////////////////////////////
bf210566 3629 // Mother Volume definition
3630 /////////////////////////////////////////////////////////////
3631 Double_t ssdchipseparation = fgkSSDSensorLength
3632 - 2.*fgkSSDModuleStiffenerPosition[1]
3633 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3634 - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
3635 Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth};
3636 Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0]
3637 +fgkSSDChipCablesWidth[1]
3638 +fgkSSDChipCablesWidth[2]);
3639 Double_t dy = fgkSSDChipCablesLength[1];
3640 Double_t dz = SSDChipCablesHeigth;
3641 TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
3642 TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother",
3643 ssdchipcablesmotherbox,fSSDAir);
3644 /////////////////////////////////////////////////////////////
3645 // Rotation and Translation Definition for positioning
3646 /////////////////////////////////////////////////////////////
3647 TGeoRotation* ssdchipcablesrot[5];
3648 ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
3649 ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
3650 ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
3651 ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
3652 ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
3653 TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,
3654 0.,0.,ssdchipcablesrot[2]);
3655 ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]);
3656 ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]);
3657 ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans);
3658 ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans);
3659 /////////////////////////////////////////////////////////////
3660 // Deallocating memory
3661 /////////////////////////////////////////////////////////////
3662 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3663 delete [] xvertexpoints[i];
3664 delete [] yvertexpoints[i];
3665 }
3666 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3667 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3668 delete vertex;
3669 delete ssdchipcablesrot[0];
3670 delete ssdchipcablesrot[1];
3671 delete ssdchipcablesrot[3];
3672 /////////////////////////////////////////////////////////////
3673 return ssdchipcablesmother;
d7599219 3674}
bf210566 3675///////////////////////////////////////////////////////////////////////////////
3676TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
3677 /////////////////////////////////////////////////////////////
3678 // SSD Chip Assembly
3679 /////////////////////////////////////////////////////////////
3680 TGeoVolume* ssdchipassembly = GetSSDChips();
3681 TList* ssdchipsystemlist = new TList();
e21cdd03 3682// const Int_t knedges = 20;
3683 const Int_t knedges = 5;
bf210566 3684 const Int_t kchipsystemnumber = 2;
3685 /////////////////////////////////////////////////////////////
3686 // Mother Volume containing SSDChipSystem
3687 /////////////////////////////////////////////////////////////
3688 TGeoXtru* chipsystemothershape[kchipsystemnumber];
3689 for(Int_t i=0; i<kchipsystemnumber; i++) chipsystemothershape[i] = new TGeoXtru(2);
3690 const Int_t kmothervertexnumber = 12;
3691 Double_t xmothervertex[kchipsystemnumber][kmothervertexnumber];
3692 Double_t ymothervertex[kchipsystemnumber][kmothervertexnumber];
3693 Double_t ssdchipcablesradius[kchipsystemnumber];
3694 Double_t ssdchipseparation = fgkSSDSensorLength
3695 - 2.*fgkSSDModuleStiffenerPosition[1]
3696 - 2.*(fgkSSDStiffenerWidth
3697 - fgkSSDStiffenerToChipDist-0.5*fgkSSDChipWidth);
3698 for(Int_t i=0; i<kchipsystemnumber; i++)
3699 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
3700 - fgkSSDChipCablesHeight[0]
3701 - fgkSSDChipCablesHeight[1]);
3702 ///////////////////////
3703 // Setting the vertices
3704 ///////////////////////
3705 xmothervertex[0][0] = -0.5*fgkSSDChipCablesLength[1];
3706 xmothervertex[0][1] = xmothervertex[0][0];
3707 xmothervertex[0][2] = (fgkSSDChipNumber-1)*(fgkSSDChipLength
3708 + fgkSSDChipSeparationLength)+0.5*fgkSSDChipCablesLength[1];
3709 xmothervertex[0][3] = xmothervertex[0][2];
3710 xmothervertex[0][4] = 0.5*fgkSSDChipCablesLength[1];
3711 xmothervertex[0][5] = xmothervertex[0][4];
3712 xmothervertex[0][6] = xmothervertex[0][2]-0.5*fgkSSDChipCablesLength[1];
3713 xmothervertex[0][7] = xmothervertex[0][6];
3714 xmothervertex[0][8] = 0.0;
3715 xmothervertex[0][9] = xmothervertex[0][8];
3716 xmothervertex[0][10] = xmothervertex[0][4];
3717 xmothervertex[0][11] = xmothervertex[0][10];
3718 for(Int_t i=0; i<kmothervertexnumber; i++)
3719 xmothervertex[1][i] = xmothervertex[0][i];
3720 for(Int_t i=0; i<kchipsystemnumber; i++){
3721 ymothervertex[i][0] = -0.5*fgkSSDChipWidth-ssdchipcablesradius[i]
3722 - fgkSSDChipCablesWidth[1]-fgkSSDChipCablesWidth[2];
3723 ymothervertex[i][1] = ssdchipseparation-ymothervertex[i][0];
3724 ymothervertex[i][2] = ymothervertex[i][1];
3725 ymothervertex[i][3] = ymothervertex[i][0];
3726 ymothervertex[i][4] = ymothervertex[i][0];
3727 ymothervertex[i][5] = 0.5*fgkSSDChipWidth;
3728 ymothervertex[i][6] = ymothervertex[i][5];
3729 ymothervertex[i][7] = ssdchipseparation-0.5*fgkSSDChipWidth;
3730 ymothervertex[i][8] = ymothervertex[i][7];
3731 ymothervertex[i][9] = ymothervertex[i][5];
3732 ymothervertex[i][10] = ymothervertex[i][5];
3733 ymothervertex[i][11] = ymothervertex[i][4];
3734 }
3735 //////////////////////////////////////////////////////////
3736 TGeoVolume* chipsystemother[kchipsystemnumber];
3737 const char* chipsytemothername[kchipsystemnumber] =
3738 {"SSDChipSytemother1","SSDChipSytemother2"};
3739 for(Int_t i=0; i<kchipsystemnumber; i++){
3740 chipsystemothershape[i]->DefinePolygon(kmothervertexnumber,
3741 xmothervertex[i],ymothervertex[i]);
3742 chipsystemothershape[i]->DefineSection(0,-fgkSSDChipCablesHeight[i+2]
3743 -0.5*fgkSSDChipHeight);
3744 chipsystemothershape[i]->DefineSection(1,0.5*fgkSSDChipHeight);
3745 chipsystemother[i] = new TGeoVolume(chipsytemothername[i],
3746 chipsystemothershape[i],fSSDAir);
3747 }
44285dfa 3748 /////////////////////////////////////////////////////////////
bf210566 3749 // SSD Chip Cables
3750 /////////////////////////////////////////////////////////////
3751 TGeoVolume* ssdchipcables[kchipsystemnumber];
3752 TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
3753 TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
3754 TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
3755 //////////////////
3756 for(Int_t i=0; i<kchipsystemnumber; i++){
3757 ssdchipcables[i] =
3758 GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
3759 ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
3760 ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
3761 ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
3762 }
3763 for(Int_t i=0; i<kchipsystemnumber; i++){
3764 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3765 ssdchipcablestrans[i][j] = new TGeoTranslation();
3766 ssdchipcablesrot[i][j] = new TGeoRotation();
3767 ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
3768 ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
3769 ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
3770 + fgkSSDChipSeparationLength),
3771 0.5*fgkSSDChipWidth,
3772 - 0.5*fgkSSDChipHeight
3773 - fgkSSDChipCablesHeight[i+2]);
3774 ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
3775 ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
3776 chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
bf210566 3777 }
3778 chipsystemother[i]->AddNode(ssdchipassembly,i+1);
e21cdd03 3779 ssdchipsystemlist->Add(chipsystemother[i]);
bf210566 3780 }
3781 /////////////////////////////////////////////////////////////
3782 // Deallocating memory
3783 /////////////////////////////////////////////////////////////
3784 for(Int_t i=0; i<kchipsystemnumber; i++){
3785 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3786 delete ssdchipcablesrot[i][j];
3787 delete ssdchipcablestrans[i][j];
3788 }
3789 delete ssdchipcablesrot[i];
3790 delete ssdchipcablestrans[i];
3791 }
3792 /////////////////////////////////////////////////////////////
3793 return ssdchipsystemlist;
d7599219 3794}
bf210566 3795///////////////////////////////////////////////////////////////////////////////
3796TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
44285dfa 3797 /////////////////////////////////////////////////////////////
bf210566 3798 // SSD Chip Assembly Generation
3799 /////////////////////////////////////////////////////////////
3800 const Int_t kssdchiprownumber = 2;
3801 TGeoBBox* ssdchipcompshape[2];
3802 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3803 0.5*fgkSSDChipLength,
3804 0.5*fgkSSDChipWidth,
3805 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3806 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3807 0.5*fgkSSDChipLength,
3808 0.5*fgkSSDChipWidth,
3809 0.5*fgkSSDChipGlueHeight);
3810 TGeoVolume* ssdchipcomp[2];
3811 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3812 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3813 fSSDChipGlueMedium);
3814 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3815 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3816 TGeoTranslation* ssdchipcomptrans[2];
3817 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3818 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3819 /////////////////////////////////////////////////////////////
3820 // Virtual Volume containing SSDChip
3821 /////////////////////////////////////////////////////////////
3822 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3823 0.5*fgkSSDChipWidth,
3824 0.5*fgkSSDChipHeight);
e21cdd03 3825 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
bf210566 3826 /////////////////////////////////////////////////////////////
3827 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3828 Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
3829 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3830 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3831 - 0.5*fgkSSDChipWidth)};
3832 /////////////////////////////////////////////////////////////
3833 // Virtual Volume containing SSDChipAssembly
3834 /////////////////////////////////////////////////////////////
3835 TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
3836 const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
3837 Double_t xmothervertex[kssdmothervertexnumber];
3838 Double_t ymothervertex[kssdmothervertexnumber];
3839 ///////////////////////
3840 // Setting the vertices
3841 ///////////////////////
3842 xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
3843 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
3844 - ymothervertex[0];
3845 xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
3846 ymothervertex[2] = ymothervertex[1];
3847 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
3848 xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
3849 ymothervertex[4] = ymothervertex[0];
3850 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
3851 xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
3852 + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
3853 ymothervertex[6] = ymothervertex[5];
3854 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
3855 - fgkSSDChipWidth;
3856 xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3857 ymothervertex[8] = ymothervertex[7];
3858 xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3859 ymothervertex[9] = ymothervertex[6];
3860 xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
3861 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
3862 //////////////////////////////////////////////////////////
3863 ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
3864 xmothervertex,ymothervertex);
3865 ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
3866 ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
3867 TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
3868 ssdchipmothershape,fSSDAir);
3869 /////////////////////////////////////////////////////////////
3870 for(Int_t i=0; i<kssdchiprownumber; i++)
3871 for(Int_t j=0; j<fgkSSDChipNumber; j++)
3872 ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
3873 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
3874 return ssdchipmother;
d7599219 3875}
bf210566 3876/////////////////////////////////////////////////////////////////////////////////
3877TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3878 /////////////////////////////////////////////////////////////
bf210566 3879 // Method returning a List containing pointers to Ladder Cable Volumes
44285dfa 3880 /////////////////////////////////////////////////////////////
bf210566 3881 const Int_t kladdercablesegmentnumber = 2;
3882 /////////////////////////////////////////
3883 // LadderSegmentBBox Volume
3884 /////////////////////////////////////////
3885 TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
3886 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3887 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3888 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3889 new TGeoBBox(laddercablesegmentbboxshapename[i],
3890 0.5*fgkSSDFlexWidth[0],
3891 0.5*fgkSSDLadderCableWidth,
3892 0.5*fgkSSDFlexHeight[i]);
3893 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3894 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3895 TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3896 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3897 laddercablesegmentbbox[i] =
3898 new TGeoVolume(laddercablesegmentbboxname[i],
3899 laddercablesegmentbboxshape[i],
3900 (i==0?fSSDAlTraceLadderCableMedium:
3901 fSSDKaptonLadderCableMedium));
3902 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3903 fColorPolyhamide);
3904 }
3905 TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
3906 laddercablesegmentbboxtrans[0] =
3907 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3908 0.5*fgkSSDFlexWidth[0],
3909 0.5*fgkSSDLadderCableWidth,
3910 0.5*fgkSSDFlexHeight[0]);
3911 laddercablesegmentbboxtrans[1] =
3912 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3913 0.5*fgkSSDFlexWidth[0],
3914 0.5*fgkSSDLadderCableWidth,
3915 fgkSSDFlexHeight[0]
3916 +0.5*fgkSSDFlexHeight[1]);
3917 TGeoVolume* laddercablesegmentbboxassembly =
3918 new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
3919 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3920 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3921 laddercablesegmentbboxtrans[i]);
3922/////////////////////////////////////////
3923// LadderSegmentArb8 Volume
3924/////////////////////////////////////////
3925 const Int_t kvertexnumber = 4;
3926 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3927 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3928 new TVector3*[kvertexnumber];
3929//Shape Vertex Positioning
3930 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3931 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3932 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3933 i*fgkSSDFlexHeight[0]);
3934 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3935 + fgkSSDFlexHeight[1]
3936 + i*fgkSSDFlexHeight[0]);
3937 laddercablesegmentvertexposition[i][3] =
3938 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3939 laddercablesegmentvertexposition[i][2]->Y());
3940 }
3941 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3942 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3943 char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3944 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3945 TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3946 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3947 GetArbShape(laddercablesegmentvertexposition[i],
3948 laddercablesegmentwidth[i],
3949 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3950 laddercablesegmentarbshapename[i]);
3951 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3952 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3953 TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3954 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3955 laddercablesegmentarb[i] =
3956 new TGeoVolume(laddercablesegmentarbname[i],
3957 laddercablesegmentarbshape[i],
3958 (i==0?fSSDAlTraceLadderCableMedium:
3959 fSSDKaptonLadderCableMedium));
3960 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3961 fColorPolyhamide);
d7599219 3962}
bf210566 3963 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3964 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3965 90.,90,-90.);
3966 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3967 0.,90.,0.);
3968 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3969 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3970 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3971 + fgkSSDFlexWidth[0],0.,0.,
3972 new TGeoRotation((*laddercablesegmentarbrot[1])
3973 *(*laddercablesegmentarbrot[0])));
3974 TGeoVolume* laddercablesegmentarbassembly =
3975 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3976 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3977 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3978 laddercablesegmentarbcombitrans);
3979/////////////////////////////////////////
3980// End Ladder Cable Volume
3981/////////////////////////////////////////
3982 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3983 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3984 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3985 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3986 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3987 0.5*ssdendladdercablelength,
3988 0.5*fgkSSDLadderCableWidth,
3989 0.5*fgkSSDFlexHeight[i]);
3990 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3991 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3992 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3993 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3994 ladderendcablesegmentbbox[i] =
3995 new TGeoVolume(ladderendcablesegmentbboxname[i],
3996 ladderendcablesegmentbboxshape[i],
3997 (i==0?fSSDAlTraceLadderCableMedium:
3998 fSSDKaptonLadderCableMedium));
3999 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
4000 fColorPolyhamide);
4001 }
4002 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
4003 ladderendcablesegmentbboxtrans[0] =
4004 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
4005 0.5*ssdendladdercablelength,
4006 0.5*fgkSSDLadderCableWidth,
4007 0.5*fgkSSDFlexHeight[0]);
4008 ladderendcablesegmentbboxtrans[1] =
4009 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
4010 0.5*ssdendladdercablelength,
4011 0.5*fgkSSDLadderCableWidth,
4012 fgkSSDFlexHeight[0]
4013 +0.5*fgkSSDFlexHeight[1]);
4014 TGeoVolume* ladderendcablesegmentbboxassembly =
4015 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
4016 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
4017 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
4018 ladderendcablesegmentbboxtrans[i]);
4019/////////////////////////////////////////
4020 TList* laddercablesegmentlist = new TList();
4021 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
4022 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
4023 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
4024 return laddercablesegmentlist;
4025 }
4026/////////////////////////////////////////////////////////////////////////////////
4027TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 4028 /////////////////////////////////////////////////////////////
bf210566 4029 // Method generating Ladder Cable Volumes Assemblies
44285dfa 4030 /////////////////////////////////////////////////////////////
bf210566 4031 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
4032 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
4033 for(Int_t i=0; i<n; i++){
4034 TGeoTranslation* laddercabletrans = new TGeoTranslation(
4035 i*(fgkCarbonFiberJunctionWidth),
4036 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4037 i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4038 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
4039 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
d7599219 4040 }
bf210566 4041 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
4042 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4043 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4044 (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4045 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
4046 return laddercable;
4047}
4048/////////////////////////////////////////////////////////////////////////////////
4049TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
4050 /////////////////////////////////////////////////////////////
4051 // Method generating Ladder Cable Volumes Assembly
4052 /////////////////////////////////////////////////////////////
4053 TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
4054 char laddercabletransname[30];
4055 for(Int_t i=0; i<n; i++){
4056 sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
4057 laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
4058 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
d7599219 4059 }
bf210566 4060 return laddercableassembly;
4061}
4062/////////////////////////////////////////////////////////////////////////////////
4063TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
4064 /////////////////////////////////////////////////////////////
4065 // Method generating Ladder Cable List Assemblies
4066 /////////////////////////////////////////////////////////////
4067 const Int_t kladdercableassemblynumber = 2;
4068 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
4069 TGeoVolume* ladderCable[kladdercableassemblynumber];
4070 char laddercableassemblyname[30];
4071 TList* laddercableassemblylist = new TList();
4072 for(Int_t i=0; i<kladdercableassemblynumber; i++){
4073 sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
4074 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
4075 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
4076 new TGeoCombiTrans((n-1)
4077 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4078 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
4079 0.,new TGeoRotation("",180,0.,0.)));
4080 laddercableassemblylist->Add(ladderCable[i]);
4081}
4082 return laddercableassemblylist;
4083}
4084///////////////////////////////////////////////////////////////////////////////
4085void AliITSv11GeometrySSD::SetLadderSegment(){
4086 /////////////////////////////////////////////////////////////
4087 // Method Generating Ladder Segment Array
4088 /////////////////////////////////////////////////////////////
4089 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
4090 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
4091 if(!fCreateMaterials) CreateMaterials();
4092 if(!fTransformationMatrices) CreateTransformationMatrices();
4093 if(!fBasicObjects) CreateBasicObjects();
4094 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
4095 // Placing Carbon Fiber Support
4096 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
4097 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4098 fcarbonfibersupportmatrix[j]);
4099 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4100 fcarbonfibersupportmatrix[j]);
d7599219 4101 }
bf210566 4102 // Placing Carbon Fiber Junction
4103 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
4104 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
4105 fcarbonfiberjunctionmatrix[j]);
4106 // Placing Carbon Fiber Lower Support
4107 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++)
4108 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
4109 fcarbonfiberlowersupportrans[j]);
4110 // Placing SSD Sensor Support
4111 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
4112 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
4113 fssdsensorsupport[1][i],
4114 j+1,fssdsensorsupportmatrix[j]);
4115 // Placing SSD Cooling Tube Support
4116 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
4117 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4118 fcoolingtubesupportmatrix[j]);
4119 // Placing SSD Cooling Tube
4120 for(Int_t j=0; j<2; j++)
4121 for(Int_t k=0; k<2; k++){
4122 fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]);
4123 fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]);
4124 }
4125 // Placing SSD Hybrid
4126 switch(i){
4127 case 0:
4128 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
4129 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4130 break;
4131 case 1:
4132 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
4133 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4134 break;
4135 }
4136 // Placing Cooling Block System
4137 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
4138 // Placing SSD Flex
4139 for(Int_t j=0; j<fgkflexnumber; j++){
4140 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
4141 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
4142 }
4143 }
d7599219 4144}
bf210566 4145///////////////////////////////////////////////////////////////////////////////
4146void AliITSv11GeometrySSD::SetEndLadderSegment(){
4147 /////////////////////////////////////////////////////////////
4148 // Method Generating End Ladder
4149 /////////////////////////////////////////////////////////////
4150 // End Ladder Carbon Fiber Junction
4151 /////////////////////////////////////////////////////////////
4152 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
4153 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
4154 if(!fCreateMaterials) CreateMaterials();
4155 if(!fTransformationMatrices) CreateTransformationMatrices();
4156 if(!fBasicObjects) CreateBasicObjects();
4157 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
4158 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
4159 fendladdersegment[i]->AddNode(j==2 ?
4160 fendladdercarbonfiberjunction[i][1] :
4161 fendladdercarbonfiberjunction[i][0],
4162 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
4163 }
4164 /////////////////////////////////////////////////////////////
4165 // End Ladder Carbon Fiber Support
4166 /////////////////////////////////////////////////////////////
4167 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
4168 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
4169 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4170 fendladdercarbonfibermatrix[i][j]);
4171 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4172 fendladdercarbonfibermatrix[i][j]);
4173 }
4174 /////////////////////////////////////////////////////////////
4175 // End Ladder Mounting Block
4176 /////////////////////////////////////////////////////////////
9b0c60ab 4177 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4178 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
e21cdd03 4179 fendladdermountingblockcombitrans[i]);
9b0c60ab 4180 /////////////////////////////////////////////////////////////
e5bf64ae 4181 // End Ladder Mounting Block Clip
9b0c60ab 4182 /////////////////////////////////////////////////////////////
4183 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4184 for(Int_t j=0; j<2; j++)
e21cdd03 4185 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
4186 fendladdermountingblockclipmatrix[i][j]);
bf210566 4187 /////////////////////////////////////////////////////////////
4188 // End Ladder Lower Supports
44285dfa 4189 /////////////////////////////////////////////////////////////
bf210566 4190 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
e21cdd03 4191 fendladderlowersupptrans[0]);
bf210566 4192 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
e21cdd03 4193 fendladderlowersupptrans[1]);
bf210566 4194 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
e21cdd03 4195 fendladderlowersupptrans[2]);
9b0c60ab 4196 /////////////////////////////////////////////////////////////
4197 // End Ladder Cooling Tube Support
4198 /////////////////////////////////////////////////////////////
4199 for(Int_t i=0; i<2; i++)
4200 for(Int_t j=0; j<(i==0?4:2); j++)
e21cdd03 4201 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4202 fendladdercoolingtubesupportmatrix[i][j]);
9b0c60ab 4203 /////////////////////////////////////////////////////////////
4204 // End Ladder Cooling Tube Support
4205 /////////////////////////////////////////////////////////////
4206 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
4207 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
4208 fendladdersegment[0]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[0][2]);
4209 fendladdersegment[0]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[0][3]);
4210 fendladdersegment[0]->AddNode(fendladdercoolingtube[2],1,fendladdercoolingtubematrix[0][4]);
4211 fendladdersegment[0]->AddNode(fendladdercoolingtube[2],2,fendladdercoolingtubematrix[0][5]);
4212 fendladdersegment[1]->AddNode(fendladdercoolingtube[3],1,fendladdercoolingtubematrix[1][0]);
4213 fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);
4214 fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);
4215 fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);
bf210566 4216}
4217///////////////////////////////////////////////////////////////////////////////
4218void AliITSv11GeometrySSD::SetLadder(){
4219 /////////////////////////////////////////////////////////////
4220 // Method Generating Ladder of Layer 5 and 6
44285dfa 4221 /////////////////////////////////////////////////////////////
bf210566 4222 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
4223 fgkSSDLay6SensorsNumber};
4224 /////////////////////////////////////////////////////////////////////////////
4225 /// Generating Ladder Mother Volume Containing Ladder
4226 /////////////////////////////////////////////////////////////////////////////
4227 TGeoXtru* laddershape[fgkladdernumber];
4228 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
4229 const Int_t kmothervertexnumber = 8;
4230 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
4231 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
4232 ///////////////////////
4233 // Setting the vertices
4234 ///////////////////////
4235 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
4236 * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
4237 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
e21cdd03 4238 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
4239 - fgkSSDModuleVerticalDisalignment;
bf210566 4240 xmothervertex[0][1] = xmothervertex[0][0];
4241 ymothervertex[0][1] = 0.0;
4242 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
4243 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
4244 ymothervertex[0][2] = ymothervertex[0][1];
4245 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
4246 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
4247 xmothervertex[0][4] = -xmothervertex[0][3];
4248 ymothervertex[0][4] = ymothervertex[0][3];
4249 xmothervertex[0][5] = -xmothervertex[0][2];
4250 ymothervertex[0][5] = ymothervertex[0][2];
4251 xmothervertex[0][6] = -xmothervertex[0][1];
4252 ymothervertex[0][6] = ymothervertex[0][1];
4253 xmothervertex[0][7] = -xmothervertex[0][0];
4254 ymothervertex[0][7] = ymothervertex[0][0];
4255 for(Int_t i=0; i<kmothervertexnumber; i++){
4256 xmothervertex[1][i] = xmothervertex[0][i];
4257 ymothervertex[1][i] = ymothervertex[0][i];
4258 }
4259 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4260 for(Int_t i=0; i<fgkladdernumber; i++){
4261 laddershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
4262 ymothervertex[i]);
4263 laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4264 laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4265 +fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4266 fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir);
9b0c60ab 4267 fladder[i]->SetLineColor(4);
bf210566 4268 }
4269///////////////////////////////////////////////////////////////////////////
4270 if(!fCreateMaterials) CreateMaterials();
4271 if(!fTransformationMatrices) CreateTransformationMatrices();
4272 if(!fBasicObjects) CreateBasicObjects();
4273 SetLadderSegment();
4274 SetEndLadderSegment();
4275 for(Int_t i=0; i<fgkladdernumber; i++){
4276 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4277 //////////////////////////
4278 /// Placing Ladder Segment
4279 //////////////////////////
4280 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4281 fladdersegment[i==0 ? 1 : 0],
4282 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4283 //////////////////////////
4284 /// Placing SSD Sensor
4285 //////////////////////////
4286 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4287 fssdsensormatrix[i][j]);
4288 }
4289 ///////////////////////////////
4290 /// Placing End Ladder Segment
4291 ///////////////////////////////
4292 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4293 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4294 }
d7599219 4295/////////////////////////////////////////////////////////////////////////////
4296/// Placing Ladder Cables
4297/////////////////////////////////////////////////////////////////////////////
bf210566 4298 Int_t sidecablenumber[2][2];
4299 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4300 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4301 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4302 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4303 Double_t carbonfibertomoduleposition[3];
4304 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4305 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4306 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4307 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4308 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4309 - fgkSSDSensorCenterSupportThickness[0]);
4310 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4311 + 0.5*fgkCoolingTubeSupportHeight
4312 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4313 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4314 Double_t ssdendladdercablelength[4];
4315 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4316 + fgkSSDSensorLength
4317 - fgkSSDModuleStiffenerPosition[1]
4318 - fgkSSDStiffenerWidth
4319 - fgkSSDFlexWidth[0]
bf210566 4320 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4321 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4322 + fgkSSDModuleStiffenerPosition[1]
4323 + fgkSSDStiffenerWidth
bf210566 4324 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4325 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4326 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4327 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4328 - kendladdercablecorrection;
44285dfa 4329 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4330 + carbonfibertomoduleposition[1]
d7599219 4331 - fgkSSDModuleStiffenerPosition[1]
4332 - fgkSSDStiffenerWidth)
bf210566 4333 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
44285dfa 4334 TList* laddercableassemblylist[4];
4335 const Int_t kendladdercablesnumber = 4;
bf210566 4336 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4337 for(Int_t j=0; j<kendladdercablesnumber; j++){
4338 laddercableassemblylist[j] =
4339 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4340 ssdendladdercablelength[j]);
4341 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4342 j<2?1:2,fladdercablematrix[i][j]);
4343 }
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],
e21cdd03 4549 fSSDCarbonFiberMedium);
9b0c60ab 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],
e21cdd03 4559 fSSDCarbonFiberMedium);
9b0c60ab 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
e21cdd03 4597 - fgkSSDModuleCoolingBlockToSensor
4598 - fgkSSDModuleVerticalDisalignment;
9b0c60ab 4599 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4600 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4601 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4602 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4603 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4604 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4605 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4606 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4607 + fgkSSDMountingBlockHeight[2]
4608 - fgkSSDMountingBlockHeight[0];
4609 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4610 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4611 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4612 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4613 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4614 mountingblockpiecedownyvertex[i]);
4615 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4616 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4617 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
e21cdd03 4618 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
9b0c60ab 4619 mountingblockpiecedown[i]->SetLineColor(fColorG10);
4620 ///////////////////////////
4621 // Mounting Block Up Vertex
4622 ///////////////////////////
4623 mountingblockpieceupshape[i] = new TGeoXtru(2);
4624 sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4625 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4626 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4627 + fgkMountingBlockSupportUpHeight[i];
4628 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4629 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4630 + fgkSSDMountingBlockHeight[1]
4631 - 0.5*fgkCoolingTubeSupportHeight
e21cdd03 4632 - fgkSSDModuleCoolingBlockToSensor
4633 - fgkSSDModuleVerticalDisalignment;
9b0c60ab 4634 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4635 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4636 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4637 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4638 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4639 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4640 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4641 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4642 + fgkSSDMountingBlockHeight[2]
4643 - fgkSSDMountingBlockHeight[0];
4644 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4645 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4646 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4647 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4648 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4649 mountingblockpieceupyvertex[i]);
4650 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4651 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4652 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
e21cdd03 4653 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
9b0c60ab 4654 mountingblockpieceup[i]->SetLineColor(fColorG10);
4655 }
4656 ///////////////////////////////////////////////////////////////////
4657 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4658 ///////////////////////////////////////////////////////////////////
4659 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4660 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4661 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4662 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4663 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4664 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4665 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4666 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4667 char mountingblocksupportrapezoidowname[40];
4668 char mountingblocksupportrapezoidupname[40];
4669 Double_t scalefactor = 3./4.;
4670 for(Int_t i=0; i<fgklayernumber; i++){
4671 ////////////////////////////////////////////
4672 // Mounting Block Support Down Trapezoid Vertex
4673 ////////////////////////////////////////////
4674 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4675 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4676 - mountingsupportedge[i];
4677 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4678 mountingblocksupportrapezoidownxvertex[i][1] =
4679 mountingblocksupportrapezoidownxvertex[i][0];
4680 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4681 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4682 - mountingblockpiecedownyvertex[i][0]);
4683 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4684 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4685 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4686 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4687 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4688 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4689 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4690 mountingblocksupportrapezoidownyvertex[i]);
4691 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4692 -fgkMountingBlockSupportWidth[0]);
4693 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4694 sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4695 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
e21cdd03 4696 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4697 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4698 ////////////////////////////////////////////
4699 // Mounting Block Support Up Trapezoid Vertex
4700 ////////////////////////////////////////////
4701 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4702 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4703 - mountingsupportedge[i];
4704 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4705 mountingblocksupportrapezoidupxvertex[i][1] =
4706 mountingblocksupportrapezoidupxvertex[i][0];
4707 mountingblocksupportrapezoidupyvertex[i][1] =
4708 mountingblockpieceupyvertex[i][0]
4709 + scalefactor*(mountingblockpieceupyvertex[i][1]
4710 - mountingblockpieceupyvertex[i][0]);
4711 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4712 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4713 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4714 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4715 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4716 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4717 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4718 mountingblocksupportrapezoidupyvertex[i]);
4719 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4720 -fgkMountingBlockSupportWidth[0]);
4721 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4722 sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4723 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
e21cdd03 4724 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4725 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4726 }
4727 ///////////////////////////////////////////////////////////////////
4728 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4729 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4730 Double_t boxoriginup[fgklayernumber][2][3];
4731 Double_t boxorigindown[fgklayernumber][2][3];
4732 char mountingblocksupportboxdownname[34];
4733 char mountingblocksupportboxupname[34];
4734 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4735 mountingblocksupportrot->SetAngles(90.,180.,-90);
4736 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4737 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4738 TGeoHMatrix* laddersupportmatrix[2];
4739 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4740 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4741 /////////////////////////////////////////////////////////////
4742 // Creating Mother Volume for Containment
4743 /////////////////////////////////////////////////////////////
4744 Double_t *xmothervertex[fgklayernumber];
4745 Double_t *ymothervertex[fgklayernumber];
4746 for(Int_t i=0; i<fgklayernumber; i++){
4747 xmothervertex[i] = new Double_t[8];
4748 ymothervertex[i] = new Double_t[8];
4749 }
4750 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4751 TGeoVolume* downmotherladdersupport[fgklayernumber];
4752 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4753 TGeoVolume* upmotherladdersupport[fgklayernumber];
4754 char upmotheladdersupportname[30];
4755 char downmotheladdersupportname[30];
4756 for(Int_t i=0; i<fgklayernumber; i++){
4757 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4758 - mountingsupportedge[i];
4759 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4760 xmothervertex[i][1] = xmothervertex[i][0];
4761 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4762 + fgkMountingBlockSupportWidth[0];
4763 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4764 ymothervertex[i][2] = ymothervertex[i][1];
4765 xmothervertex[i][3] = xmothervertex[i][2];
4766 ymothervertex[i][3] = -ymothervertex[i][0];
4767 xmothervertex[i][4] = -xmothervertex[i][0];
4768 ymothervertex[i][4] = ymothervertex[i][3];
4769 xmothervertex[i][5] = xmothervertex[i][4];
4770 ymothervertex[i][5] = -ymothervertex[i][1];
4771 xmothervertex[i][6] = -xmothervertex[i][2];
4772 ymothervertex[i][6] = ymothervertex[i][5];
4773 xmothervertex[i][7] = xmothervertex[i][6];
4774 ymothervertex[i][7] = ymothervertex[i][0];
4775 sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4776 sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
4777 downmotherladdersupportshape[i] = new TGeoXtru(2);
4778 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4779 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4780 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4781 + fgkMountingBlockSupportDownHeight
4782 + fgkSSDMountingBlockHeight[1]
4783 - 0.5*fgkCoolingTubeSupportHeight
e21cdd03 4784 - fgkSSDModuleCoolingBlockToSensor
606d8cca 4785 - 2.*fgkSSDModuleVerticalDisalignment);
9b0c60ab 4786 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4787 downmotherladdersupportshape[i],fSSDAir);
4788 upmotherladdersupportshape[i] = new TGeoXtru(2);
4789 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4790 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4791 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4792 + fgkMountingBlockSupportUpHeight[i]
4793 + fgkSSDMountingBlockHeight[1]
4794 - 0.5*fgkCoolingTubeSupportHeight
e21cdd03 4795 - fgkSSDModuleCoolingBlockToSensor
606d8cca 4796 - 2.*fgkSSDModuleVerticalDisalignment);
9b0c60ab 4797 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4798 upmotherladdersupportshape[i],fSSDAir);
4799 }
4800 for(Int_t i=0; i<fgklayernumber; i++){
4801 /////////////////////////
4802 // Setting the box origin
4803 /////////////////////////
4804 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4805 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
4806 + 0.5*fgkMountingBlockSupportDownHeight;
4807 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4808 - 0.5*fgkMountingBlockSupportWidth[0];
4809
4810 boxorigindown[i][1][0] = 0.0;
4811 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4812 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4813 - fgkMountingBlockSupportWidth[0]);
4814
4815 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4816 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4817 + 0.5*fgkMountingBlockSupportUpHeight[i];
4818 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4819 - 0.5*fgkMountingBlockSupportWidth[0];
4820
4821 boxoriginup[i][1][0] = 0.0;
4822 boxoriginup[i][1][1] = fgkMountingBlockSupportRadius[i]
4823 + 0.5*fgkMountingBlockSupportUpHeight[i];
4824 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4825 - fgkMountingBlockSupportWidth[0]);
4826
4827 /////////////////////////
4828 // Setting the boxes
4829 /////////////////////////
4830 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4831 + fgkSSDMountingBlockLength[0]),
4832 0.5*fgkMountingBlockSupportDownHeight,
4833 0.5*fgkMountingBlockSupportWidth[0],
4834 boxorigindown[i][0]);
4835 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4836 0.5*fgkMountingBlockSupportDownHeight,
4837 0.5*(fgkMountingBlockSupportWidth[1]
4838 - fgkMountingBlockSupportWidth[0]),
4839 boxorigindown[i][1]);
4840
4841 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4842 + fgkSSDMountingBlockLength[0]),
4843 0.5*fgkMountingBlockSupportUpHeight[i],
4844 0.5*fgkMountingBlockSupportWidth[0],
4845 boxoriginup[i][0]);
4846
4847 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4848 0.5*fgkMountingBlockSupportUpHeight[i],
4849 0.5*(fgkMountingBlockSupportWidth[1]
4850 - fgkMountingBlockSupportWidth[0]),
4851 boxoriginup[i][1]);
4852 ///////////////////////////////////////
4853 // Adding the Volumes to Mother Volume
4854 ///////////////////////////////////////
4855 for(Int_t j=0; j<2; j++){
4856 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4857 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4858 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4859 mountingblocksupportboxdownshape[i][j],
e21cdd03 4860 fSSDCarbonFiberMedium);
9b0c60ab 4861 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4862 mountingblocksupportboxupshape[i][j],
e21cdd03 4863 fSSDCarbonFiberMedium);
9b0c60ab 4864 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4865 mountingblocksupportboxup[i][j]->SetLineColor(9);
4866 for(Int_t k=0; k<2; k++){
4867 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4868 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4869 }
4870 }
4871 for(Int_t k=0; k<2; k++){
4872 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4873 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4874 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4875 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4876 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4877 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4878 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4879 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4880 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4881 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4882 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4883 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
4884 }
4885 }
4886 TList* laddersupportlist = new TList();
4887 laddersupportlist->Add(downmotherladdersupport[0]);
4888 laddersupportlist->Add(upmotherladdersupport[0]);
4889 laddersupportlist->Add(downmotherladdersupport[1]);
4890 laddersupportlist->Add(upmotherladdersupport[1]);
4891 /////////////////////////////////////////////////////////////
4892 // Deallocating memory
4893 /////////////////////////////////////////////////////////////
4894 for(Int_t i=0; i<fgklayernumber; i++){
4895 for(Int_t j=0; j<nedges+1; j++)
4896 delete vertex[i][j];
4897 delete mountingsupportedgevector[i];
4898 delete [] vertex[i];
4899 delete vertexlist[i];
4900 delete [] xsidevertex[i];
4901 delete [] ysidevertex[i];
4902 delete [] xcentervertex[i];
4903 delete [] ycentervertex[i];
4904 delete [] xsidelowervertex[i];
4905 delete [] ysidelowervertex[i];
4906 delete [] xcenterlowervertex[i];
4907 delete [] ycenterlowervertex[i];
4908 }
4909 delete xsidevertex;
4910 delete ysidevertex;
4911 delete xcentervertex;
4912 delete ycentervertex;
4913 delete xsidelowervertex;
4914 delete ysidelowervertex;
4915 delete xcenterlowervertex;
4916 delete ycenterlowervertex;
4917 delete globalrefladdersupportrot;
4918 delete mountingblocksupportrot;
4919 /////////////////////
4920 return laddersupportlist;
4921}
4922 ////////////////////////////////////////////////////////////////////////////////
4923void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4924//////////////////////////////////////////
4925// Method Generating Ladder Support Ring
4926//////////////////////////////////////////
4927 if(!fCreateMaterials) CreateMaterials();
4928 if(!fTransformationMatrices) CreateTransformationMatrices();
4929 if(!fBasicObjects) CreateBasicObjects();
4930 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4931 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4932 const Int_t kssdlayladdernumber[fgklayernumber] =
4933 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4934 Double_t mountingsupportedge[fgklayernumber];
4935 Double_t mountingblockratio[fgklayernumber];
4936 Double_t theta[fgklayernumber];
4937 Double_t phi[fgklayernumber];
4938 for(Int_t i=0; i<fgklayernumber; i++){
4939 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4940 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4941 *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4942 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4943 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4944 / kssdlayladdernumber[i])));
4945 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4946 / fgkMountingBlockSupportRadius[i]);
4947 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4948 }
4949 TGeoRotation* globalrot = new TGeoRotation();
4950 globalrot->SetAngles(0.,-90.,0.);
4951 TGeoRotation** laddersupportrot[fgklayernumber];
4952 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4953 for(Int_t i=0; i<fgklayernumber; i++){
4954 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4955 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4956 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4957 laddersupportrot[i][j] = new TGeoRotation();
4958 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4959 switch(i){
4960 case 0: //Ladder of Layer5
4961 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4962 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4963 laddersupportmatrix[i][j]);
4964 break;
4965 case 1: //Ladder of Layer6
4966 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4967 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4968 laddersupportmatrix[i][j]);
4969 break;
4970 }
4971 }
4972 }
4973 /////////////////////////////////////////////////////////////
4974 // Creating Lower Ladder Support
4975 /////////////////////////////////////////////////////////////
4976 TVector3** ringsupportvertex[fgklayernumber];
4977 Double_t angle = 360./nedges;
4978 for(Int_t i=0; i<fgklayernumber; i++){
4979 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4980 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4981 * TMath::Cos(theta[i]));
4982 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4983 - mountingsupportedge[i],
4984 ringsupportvertex[i][0]->Y());
4985 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4986 ringsupportvertex[i][1]->Y());
4987 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4988 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4989 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4990 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4991 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4992 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4993 }
4994 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4995 for(Int_t j=0; j<nedges+1; j++){
4996 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
4997 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*CosD(90.0-j*angle),
4998 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*SinD(90.0-j*angle));
4999 }
5000 }
5001 Double_t **xmothervertex = new Double_t*[fgklayernumber];
5002 Double_t **ymothervertex = new Double_t*[fgklayernumber];
5003 for(Int_t i=0; i<fgklayernumber; i++){
5004 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5005 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5006 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
5007 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
5008 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
5009 }
5010 }
5011 char lowerladdersupportname[30];
5012 TGeoXtru* lowerladdersupportshape[fgklayernumber];
5013 TGeoVolume* lowerladdersupport[fgklayernumber];
5014 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5015 lowerladdersupportrot->SetAngles(90.,180.,-90);
5016 for(Int_t i=0; i<fgklayernumber; i++){
5017 lowerladdersupportshape[i] = new TGeoXtru(2);
5018 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
5019 xmothervertex[i],ymothervertex[i]);
5020 lowerladdersupportshape[i]->DefineSection(0,0.);
5021 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
5022 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
5023 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
5024 lowerladdersupportshape[i],fSSDSupportRingAl);
5025 lowerladdersupport[i]->SetLineColor(fColorAl);
5026 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
5027 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
5028 }
5029 /////////////////////////////////////////////////////////////
5030 // Deallocating memory
5031 /////////////////////////////////////////////////////////////
5032 for(Int_t i=0; i<fgklayernumber; i++){
5033 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
5034 delete ringsupportvertex[i][j];
5035 delete [] ringsupportvertex[i];
5036 }
5037 for(Int_t i=0; i<fgklayernumber; i++){
5038 delete [] xmothervertex[i];
5039 delete [] ymothervertex[i];
5040 }
5041 delete xmothervertex;
5042 delete ymothervertex;
5043 delete globalrot;
5044 for(Int_t i=0; i<fgklayernumber; i++){
5045 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
5046 delete laddersupportrot[i][j];
5047 delete [] laddersupportrot[i];
5048 }
5049 }
5050 ////////////////////////////////////////////////////////////////////////////////
5051 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
5052 /////////////////////////////////////////////////////////////
5053 // Method generating Endcap CoverPlate
5054 /////////////////////////////////////////////////////////////
5055 // Holes Definition
5056 ///////////////////
5057 Int_t nendcapcoverplateholedges = 30;
5058 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
5059 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
5060 0.5*fgkEndCapCoverPlateThickness};
5061 TGeoXtru* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
5062 nendcapcoverplateholedges,holesection);
5063 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 5064 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 5065 endcapcoverplatesmallhole->SetLineColor(6);
5066 TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
5067 nendcapcoverplateholedges,holesection);
5068 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 5069 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 5070 endcapcoverplatebighole->SetLineColor(6);
5071 //////////////////////////
5072 // Screw Piece Definition
5073 //////////////////////////
5074 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
5075 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
5076 CosD(0.5*smallscrewangle),
5077 0.5*fgkEndCapCoverPlateThickness);
5078 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
5079 endcapsmallscrewpieceshape,
5080 fSSDCoolingTubePhynox);
5081 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
5082 ///////////////////
5083 // Box Definition
5084 ///////////////////
5085 TGeoBBox* endcapcoverplateboxshape[4];
5086 TGeoVolume* endcapcoverplatebox[4];
5087 Double_t boxorigin[5][3];
5088 boxorigin[0][0] = 0.;
5089 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
5090 boxorigin[0][2] = 0.;
5091
5092 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
5093 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
5094 boxorigin[1][2] = 0.;
5095
5096 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
5097 + fgkEndCapCoverPlateSmallHoleSeparation[1];
5098 boxorigin[2][1] = boxorigin[1][1];
5099 boxorigin[2][2] = 0.;
5100
5101 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
5102 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
5103 boxorigin[3][1] = boxorigin[1][1];
5104 boxorigin[3][2] = 0.;
5105
5106 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5107 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5108 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
5109 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5110
5111 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5112 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5113 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5114 + fgkEndCapCoverPlateSmallHoleRadius,
5115 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5116
5117 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5118 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5119 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5120 + fgkEndCapCoverPlateSmallHoleRadius,
5121 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5122
5123 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5124 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5125 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5126 + fgkEndCapCoverPlateSmallHoleRadius,
5127 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5128
5129 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 5130 fSSDAlCoolBlockMedium);
9b0c60ab 5131 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 5132 fSSDAlCoolBlockMedium);
9b0c60ab 5133 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 5134 fSSDAlCoolBlockMedium);
9b0c60ab 5135 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 5136 fSSDAlCoolBlockMedium);
9b0c60ab 5137 endcapcoverplatebox[0]->SetLineColor(6);
5138 endcapcoverplatebox[1]->SetLineColor(6);
5139 endcapcoverplatebox[2]->SetLineColor(6);
5140 endcapcoverplatebox[3]->SetLineColor(6);
5141 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5142 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5143 fgkEndCapCoverPlateSmallHoleRadius,
5144 0.5*fgkEndCapCoverPlateThickness,
5145 endcapfillingboxorigin);
5146 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 5147 fSSDAlCoolBlockMedium);
9b0c60ab 5148 endcapfillingbox->SetLineColor(6);
5149 ////////////////////////////
5150 // Contour Xtru Definition
5151 ////////////////////////////
5152 const Int_t kcontourvertexnumber = 10;
5153 Double_t xcontourvertex[kcontourvertexnumber];
5154 Double_t ycontourvertex[kcontourvertexnumber];
5155 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5156 xcontourvertex[1] = xcontourvertex[0];
5157 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5158 xcontourvertex[3] = xcontourvertex[2];
5159 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5160 xcontourvertex[5] = xcontourvertex[4];
5161 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5162 xcontourvertex[7] = xcontourvertex[6];
5163 xcontourvertex[8] = xcontourvertex[4];
5164 xcontourvertex[9] = xcontourvertex[8];
5165 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5166 - (kendcapcoverplatesmallholenumber[1]-1)
5167 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5168 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5169 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5170 ycontourvertex[2] = ycontourvertex[1];
5171 ycontourvertex[3] = ycontourvertex[0];
5172 ycontourvertex[4] = ycontourvertex[3];
5173 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5174 ycontourvertex[6] = ycontourvertex[5];
5175 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5176 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5177 + fgkEndCapCoverPlateSmallHoleRadius;
5178 ycontourvertex[8] = ycontourvertex[7];
5179 ycontourvertex[9] = ycontourvertex[0];
5180 TGeoXtru* contourshape = new TGeoXtru(2);
5181 contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex);
5182 contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5183 contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
e21cdd03 5184 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5185 fSSDAlCoolBlockMedium);
9b0c60ab 5186 contour->SetLineColor(6);
5187 /////////////////////////////
5188 // Hole Contour Xtru Definition
5189 ////////////////////////////
5190 const Int_t kholecontourvertexnumber = 10;
5191 Double_t xholecontourvertex[2][kcontourvertexnumber];
5192 Double_t yholecontourvertex[2][kcontourvertexnumber];
5193 xholecontourvertex[0][0] = xcontourvertex[0];
5194 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5195 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5196 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5197 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5198 + 0.5*(fgkEndCapCoverPlateLength[2]
5199 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5200 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5201 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5202 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5203 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5204 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5205 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5206
5207 yholecontourvertex[0][0] = ycontourvertex[1];
5208 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5209 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5210 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5211 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5212 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5213 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5214 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5215 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5216 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5217 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5218
5219 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5220 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5221 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5222 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5223 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5224 + 0.5*(fgkEndCapCoverPlateLength[2]
5225 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5226 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5227 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5228 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5229 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5230 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5231 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5232
5233 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5234 - fgkEndCapCoverPlateWidth[0]);
5235 yholecontourvertex[1][1] = ycontourvertex[0];
5236 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5237 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5238 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5239 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5240 - fgkEndCapCoverPlateWidth[0]
5241 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5242 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5243 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5244 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5245 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5246
5247 TGeoXtru* holecontourshape[2];
5248 holecontourshape[0] = new TGeoXtru(2);
5249 holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0],
5250 yholecontourvertex[0]);
5251 holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5252 holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5253
5254 holecontourshape[1] = new TGeoXtru(2);
5255 holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1],
5256 yholecontourvertex[1]);
5257 holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5258 holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5259
5260 TGeoVolume* holecontour[2];
e21cdd03 5261 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0],
5262 fSSDAlCoolBlockMedium);
9b0c60ab 5263 holecontour[0]->SetLineColor(6);
e21cdd03 5264 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1],
5265 fSSDAlCoolBlockMedium);
9b0c60ab 5266 holecontour[1]->SetLineColor(6);
5267 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5268 + fgkEndCapCoverPlateLength[2],0.,0.);
5269 TGeoTranslation* bigholetrans[3];
5270 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5271 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5272 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5273 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5274 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5275 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5276 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5277 /////////////////////////////////
5278 // Mother Volume Xtru Definition
5279 /////////////////////////////////
5280 const Int_t kmothervertexnumber = 12;
5281 Double_t xmothervertex[kmothervertexnumber];
5282 Double_t ymothervertex[kmothervertexnumber];
5283 xmothervertex[0] = xcontourvertex[0];
5284 xmothervertex[1] = xmothervertex[0];
5285 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5286 xmothervertex[3] = xmothervertex[2];
5287 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5288 xmothervertex[5] = xmothervertex[4];
5289 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5290 xmothervertex[7] = xmothervertex[6];
5291 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5292 + fgkEndCapCoverPlateLength[2];
5293 xmothervertex[9] = xmothervertex[8];
5294 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5295 xmothervertex[11] = xmothervertex[10];
5296
5297 ymothervertex[0] = ycontourvertex[0];
5298 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5299 ymothervertex[2] = ymothervertex[1];
5300 ymothervertex[3] = ycontourvertex[1];
5301 ymothervertex[4] = ymothervertex[3];
5302 ymothervertex[5] = ymothervertex[1];
5303 ymothervertex[6] = ymothervertex[5];
5304 ymothervertex[7] = ymothervertex[0];
5305 ymothervertex[8] = ymothervertex[7];
5306 ymothervertex[9] = ymothervertex[8]
5307 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5308 ymothervertex[10] = ymothervertex[9];
5309 ymothervertex[11] = ymothervertex[8];
5310 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5311 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5312 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5313 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5314 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5315 ////////////////////////////////////////
5316 // Adding Nodes
5317 ////////////////////////////////////////
5318// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5319 TGeoTranslation*** endcapcoverplatesmallholetrans;
5320 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5321 Double_t transx[4] = {0,
5322 fgkEndCapCoverPlateSmallHoleSeparation[0],
5323 fgkEndCapCoverPlateSmallHoleSeparation[0]
5324 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5325 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5326 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5327 Int_t index = 0;
5328 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5329 endcapcoverplatesmallholetrans[i] =
5330 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5331 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5332 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5333 endcapcoverplatesmallholetrans[i][j] =
5334 new TGeoTranslation(transx[i],
5335 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5336 if(index!=10){
5337 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5338 index,endcapcoverplatesmallholetrans[i][j]);
5339 mothercoverplate->AddNode(endcapsmallscrewpiece,
5340 index,endcapcoverplatesmallholetrans[i][j]);
5341 }
5342 if(j<kendcapcoverplatesmallholenumber[1]-1)
5343 mothercoverplate->AddNode(endcapcoverplatebox[0],
5344 index,endcapcoverplatesmallholetrans[i][j]);
5345 }
5346 }
5347 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5348 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5349 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5350 mothercoverplate->AddNode(endcapfillingbox,1);
5351 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5352 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5353 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5354 mothercoverplate->AddNode(holecontour[0],1);
5355 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5356 mothercoverplate->AddNode(holecontour[1],1);
5357 mothercoverplate->AddNode(contour,1);
5358 /////////////////////////////////
5359 return mothercoverplate;
5360 }
5361 ////////////////////////////////////////////////////////////////////////////////
5362 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5363 /////////////////////////////////////////////////////////////
5364 // Getting EndCap Cooling Tube
5365 /////////////////////////////////////////////////////////////
5366 TGeoTorus* endcapcoolingtubetorushape[5];
5367 TGeoVolume* endcapcoolingtubetorus[5];
5368 TGeoTube* endcapcoolingtubeshape[4];
5369 TGeoVolume* endcapcoolingtube[4];
5370 char endcapcoolingtubetorusname[30];
5371 char endcapcoolingtubename[30];
5372 TGeoTorus* endcapcoolingwatertubetorushape[5];
5373 TGeoVolume* endcapcoolingwatertubetorus[5];
5374 TGeoTube* endcapcoolingwatertubeshape[4];
5375 TGeoVolume* endcapcoolingwatertube[4];
5376 char endcapcoolingwatertubetorusname[30];
5377 char endcapcoolingwatertubename[30];
5378 for(Int_t i=0; i<5; i++){
5379 sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5380 sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5381 sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5382 sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5383 if(i==3){
5384 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5385 fgkEndCapCoolingTubeRadiusMin,
5386 fgkEndCapCoolingTubeRadiusMax,
5387 90.0,fgkEndCapCoolingTubeAngle[3]);
5388 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5389 0.,fgkEndCapCoolingTubeRadiusMin,
5390 90.0,fgkEndCapCoolingTubeAngle[3]);
5391 }
5392 else{
5393 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5394 :fgkEndCapCoolingTubeAxialRadius[1],
5395 fgkEndCapCoolingTubeRadiusMin,
5396 fgkEndCapCoolingTubeRadiusMax,
5397 0.,fgkEndCapCoolingTubeAngle[i]);
5398 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5399 :fgkEndCapCoolingTubeAxialRadius[1],
5400 0.,fgkEndCapCoolingTubeRadiusMin,
5401 0.,fgkEndCapCoolingTubeAngle[i]);
5402 }
5403 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5404 endcapcoolingtubetorushape[i],
5405 fSSDCoolingTubePhynox);
5406 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5407 endcapcoolingwatertubetorushape[i],
5408 fSSDCoolingTubeWater);
5409 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5410 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5411 if(i<4){
5412 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5413 fgkEndCapCoolingTubeRadiusMax,
5414 0.5*fgkEndCapCoolingTubeLength[i]);
5415 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5416 0.5*fgkEndCapCoolingTubeLength[i]);
5417 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5418 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5419 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5420 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5421 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5422 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5423 }
5424 }
5425 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5426 /////////////////////////////////////////
5427 // Transformation for Volume Positioning
5428 /////////////////////////////////////////
5429 TGeoCombiTrans* coolingtubecombitrans[6];
5430 TGeoRotation* coolingtuberot[8];
5431 TGeoTranslation* coolingtubetrans[6];
5432 TGeoHMatrix* coolingtubematrix[4];
5433 TGeoCombiTrans* torustubecombitrans[4];
5434 TGeoRotation* torustuberot[7];
5435 TGeoTranslation* torustubetrans[4];
5436 TGeoHMatrix* torustubematrix[5];
5437 TGeoCombiTrans* coolingwatertubecombitrans[6];
5438 TGeoRotation* coolingwatertuberot[8];
5439 TGeoTranslation* coolingwatertubetrans[6];
5440 TGeoHMatrix* coolingwatertubematrix[4];
5441 TGeoCombiTrans* toruswatertubecombitrans[4];
5442 TGeoRotation* toruswatertuberot[7];
5443 TGeoTranslation* toruswatertubetrans[4];
5444 TGeoHMatrix* toruswatertubematrix[5];
5445 for(Int_t i=0; i<8; i++){
5446 if(i<6){
5447 coolingtubetrans[i] = new TGeoTranslation();
5448 coolingwatertubetrans[i] = new TGeoTranslation();
5449 }
5450 if(i<8){
5451 coolingtuberot[i] = new TGeoRotation();
5452 coolingwatertuberot[i] = new TGeoRotation();
5453 }
5454 if(i<4){
5455 torustubetrans[i] = new TGeoTranslation();
5456 toruswatertubetrans[i] = new TGeoTranslation();
5457 }
5458 if(i<7){
5459 torustuberot[i] = new TGeoRotation();
5460 toruswatertuberot[i] = new TGeoRotation();
5461 }
5462 }
5463 /////////////////////////////////////////
5464 // Transformation for Inox Volume Positioning
5465 /////////////////////////////////////////
5466 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5467 -endcapcoolingtubeshape[0]->GetDz(),0.);
5468 coolingtuberot[0]->SetAngles(0.,90.,0.);
5469 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5470 *coolingtuberot[0]);
5471
5472 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5473 coolingtuberot[1]->SetAngles(0.,90.,0.);
5474 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5475 *coolingtuberot[1]);
5476
5477 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5478 *CosD(fgkEndCapCoolingTubeAngle[0]),
5479 fgkEndCapCoolingTubeAxialRadius[0]
5480 *SinD(fgkEndCapCoolingTubeAngle[0]),
5481 0.);
5482 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5483 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5484 *coolingtuberot[2]);
5485
5486 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5487 * (*coolingtubecombitrans[1]));
5488
5489 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5490 endcapcoolingtubeshape[1]->GetDz());
5491 torustuberot[0]->SetAngles(0.,90.,0.);
5492 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5493
5494 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5495
5496 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5497 -endcapcoolingtubeshape[2]->GetDz(),0.);
5498 coolingtuberot[3]->SetAngles(0.,90.,0.);
5499 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5500 *coolingtuberot[3]);
5501 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5502 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5503 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5504
5505 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5506 endcapcoolingtubeshape[2]->GetDz());
5507 torustuberot[1]->SetAngles(0.,90.,0.);
5508 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5509 torustuberot[2]->SetAngles(180.,0.,0.);
5510 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5511 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5512
5513 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5514 -fgkEndCapCoolingTubeAxialRadius[0]);
5515 torustuberot[3]->SetAngles(0.,90.,0.);
5516 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5517 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5518 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5519 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5520
5521 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5522 fgkEndCapCoolingTubeAxialRadius[0],0.);
5523 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5524 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5525 *coolingtuberot[5]);
5526 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5527 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5528 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5529
5530 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5531 endcapcoolingtubeshape[0]->GetDz());
5532 torustuberot[5]->SetAngles(0.,90.,0.);
5533 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5534 torustuberot[6]->SetAngles(-90.,0.,0.);
5535 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5536 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5537
5538 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5539 endcapcoolingtubeshape[3]->GetDz(),0.);
5540 coolingtuberot[6]->SetAngles(0.,90.,0.);
5541 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5542 *coolingtuberot[6]);
5543 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5544 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5545 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5546 /////////////////////////////////////////
5547 // Transformation for Water Volume Positioning
5548 /////////////////////////////////////////
5549 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5550 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5551 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5552 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5553 *coolingwatertuberot[0]);
5554
5555 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5556 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5557 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5558 *coolingwatertuberot[1]);
5559
5560 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5561 *CosD(fgkEndCapCoolingTubeAngle[0]),
5562 fgkEndCapCoolingTubeAxialRadius[0]
5563 *SinD(fgkEndCapCoolingTubeAngle[0]),
5564 0.);
5565 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5566 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5567 *coolingwatertuberot[2]);
5568
5569 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5570 * (*coolingwatertubecombitrans[1]));
5571
5572 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5573 endcapcoolingwatertubeshape[1]->GetDz());
5574 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5575 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5576 *toruswatertuberot[0]);
5577
5578 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5579 * (*toruswatertubecombitrans[0]));
5580
5581 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5582 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5583 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5584 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5585 *coolingwatertuberot[3]);
5586 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5587 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5588 * (*coolingwatertubecombitrans[3]));
5589 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5590
5591 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5592 endcapcoolingwatertubeshape[2]->GetDz());
5593 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5594 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5595 *toruswatertuberot[1]);
5596 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5597 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5598 * (*toruswatertubecombitrans[1]));
5599 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5600
5601 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5602 -fgkEndCapCoolingTubeAxialRadius[0]);
5603 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5604 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5605 *toruswatertuberot[3]);
5606 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5607 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5608 * (*toruswatertubecombitrans[2]));
5609 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5610
5611 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5612 fgkEndCapCoolingTubeAxialRadius[0],0.);
5613 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5614 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5615 *coolingwatertuberot[5]);
5616 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5617 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5618 * (*coolingwatertubecombitrans[4]));
5619 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5620
5621 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5622 endcapcoolingwatertubeshape[0]->GetDz());
5623 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5624 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5625 *toruswatertuberot[5]);
5626 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5627 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5628 * (*toruswatertubecombitrans[3]));
5629 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5630
5631 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5632 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5633 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5634 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5635 *coolingwatertuberot[6]);
5636 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5637 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5638 * (*coolingwatertubecombitrans[5]));
5639 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5640 /////////////////////////////////////////
5641 // Positioning Volumes
5642 /////////////////////////////////////////
5643 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5644 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5645
5646 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5647 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5648
5649 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5650 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5651
5652 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5653 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5654
5655 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5656 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5657
5658 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5659 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5660
5661 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5662 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5663
5664 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5665 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5666
5667 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5668 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5669
5670 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5671 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5672 /////////////////////////////////////////////////////////////
5673 // Deallocating memory
5674 /////////////////////////////////////////////////////////////
5675 for(Int_t i=0; i<8; i++){
5676 if(i<6){
5677 delete coolingtubetrans[i];
5678 delete coolingwatertubetrans[i];
5679 if(i!=0){
5680 delete coolingtubecombitrans[i];
5681 delete coolingwatertubecombitrans[i];
5682 }
5683 }
5684 if(i<8){
5685 delete coolingtuberot[i];
5686 delete coolingwatertuberot[i];
5687 }
5688 if(i<4){
5689 delete torustubetrans[i];
5690 delete toruswatertubetrans[i];
5691 delete torustubecombitrans[i];
5692 delete toruswatertubecombitrans[i];
5693 }
5694 if(i<7){
5695 delete torustuberot[i];
5696 delete toruswatertuberot[i];
5697 }
5698 }
5699 /////////////////////////////////////////////////////////////
5700 return endcapcoolingtubemother;
5701 }
5702 ////////////////////////////////////////////////////////////////////////////////
5703 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5704 /////////////////////////////////////////////////////////////
5705 // Getting EndCap Cover Side
5706 /////////////////////////////////////////////////////////////
5707 const Int_t kendcapcoverholenumber[2] = {7,5};
5708 const Int_t kvertexnumber = 15;
5709 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5710 xvertex[0] = 0.0;
5711 xvertex[1] = xvertex[0];
5712 xvertex[2] = fgkEndCapSideCoverLength[0];
5713 xvertex[3] = fgkEndCapSideCoverLength[1];
5714 xvertex[4] = xvertex[3];
5715 xvertex[5] = fgkEndCapSideCoverLength[2];
5716 xvertex[6] = xvertex[5];
5717 xvertex[7] = xvertex[2];
5718 xvertex[8] = xvertex[7];
5719 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5720 xvertex[10] = xvertex[9];
5721 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5722 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5723 * fgkEndCapSideCoverLength[4];
5724 xvertex[12] = xvertex[11];
5725 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5726 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5727 * fgkEndCapSideCoverLength[4];
5728 xvertex[14] = xvertex[13];
5729 yvertex[0] = 0.0;
5730 yvertex[1] = fgkEndCapSideCoverWidth[0];
5731 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5732 yvertex[3] = yvertex[2];
5733 yvertex[4] = fgkEndCapSideCoverWidth[1];
5734 yvertex[5] = yvertex[4];
5735 yvertex[6] = yvertex[0];
5736 yvertex[7] = yvertex[6];
5737 yvertex[8] = fgkEndCapSideCoverWidth[6];
5738 yvertex[9] = yvertex[8];
5739 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5740 yvertex[11] = yvertex[10];
5741 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5742 yvertex[13] = yvertex[12];
5743 yvertex[14] = yvertex[6];
5744 TGeoXtru* endcapsidecovershape = new TGeoXtru(2);
5745 endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex);
5746 endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5747 endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5748 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5749 endcapsidecovershape,fSSDCoolingTubePhynox);
5750 endcapsidecover->SetLineColor(fColorPhynox);
5751 ////////////////////////////////////////////
5752 // Defininition of Mother Volume
5753 ////////////////////////////////////////////
5754 const Int_t kmothervertexnumber = 7;
5755 Double_t xmothervertex[kmothervertexnumber];
5756 Double_t ymothervertex[kmothervertexnumber];
5757 for(Int_t i=0; i<kmothervertexnumber; i++){
5758 xmothervertex[i] = xvertex[i];
5759 ymothervertex[i] = yvertex[i];
5760 }
5761 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5762 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5763 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5764 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5765 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5766 endcapsidecovermothershape,fSSDAir);
5767 ////////////////////////////////////////////
5768 endcapsidecovermother->AddNode(endcapsidecover,1);
5769 TGeoBBox* endcapsidecoverboxshape[4];
5770 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5771 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5772 0.5*fgkEndCapSideCoverLength[4],
5773 0.5*fgkEndCapSideCoverThickness);
5774 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5775 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5776 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5777 - fgkEndCapSideCoverLength[4]),
5778 0.5*fgkEndCapSideCoverThickness);
5779 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5780 0.5*fgkEndCapSideCoverLength[4],
5781 0.5*fgkEndCapSideCoverThickness);
5782 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5783 0.5*fgkEndCapSideCoverWidth[5],
5784 0.5*fgkEndCapSideCoverThickness);
5785 TGeoVolume* endcapsidecoverbox[4];
5786 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5787 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5788 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5789 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5790 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5791// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5792 TGeoTranslation** endcapsidecoverboxtrans;
5793 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5794 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5795 + fgkEndCapSideCoverLength[0],
5796 endcapsidecoverboxshape[0]->GetDY()
5797 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5798 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5799 + xvertex[11],
5800 endcapsidecoverboxshape[1]->GetDY()
5801 + yvertex[12],0.);
5802 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5803 + xvertex[11],
5804 endcapsidecoverboxshape[2]->GetDY()
5805 + yvertex[12]
5806 + 2.*endcapsidecoverboxshape[1]->GetDY()
5807 + fgkEndCapSideCoverWidth[5],0.);
5808 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5809 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5810 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5811 for(Int_t i=0; i<2; i++)
5812 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5813 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5814 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5815 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5816 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5817 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5818 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5819 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5820 }
5821 for(Int_t i=0; i<2; i++)
5822 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5823 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5824 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5825 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5826 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5827 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5828 +fgkEndCapSideCoverLength[4]),0.0);
5829 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5830 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5831 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5832 +i*(kendcapcoverholenumber[1]-1)+j]);
5833 }
5834 return endcapsidecovermother;
5835 }
5836 ////////////////////////////////////////////////////////////////////////////////
5837 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5838 ////////////////////////////////////////////////////////////////////////////////
5839 // Method returning Interface Card A, Interface Card B, Supply Card
5840 ////////////////////////////////////////////////////////////////////////////////
5841 /////////////////////
5842 // Supply Card
5843 /////////////////////
5844 // Electronic Board Back Al Plane
5845 const Int_t kelectboardbackvertexnumber = 8;
5846 Double_t xelectboardback[kelectboardbackvertexnumber];
5847 Double_t yelectboardback[kelectboardbackvertexnumber];
5848 xelectboardback[0] = 0.0;
5849 xelectboardback[1] = xelectboardback[0];
5850 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5851 xelectboardback[3] = xelectboardback[2];
5852 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5853 xelectboardback[5] = xelectboardback[4];
5854 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5855 xelectboardback[7] = xelectboardback[6];
5856
5857 yelectboardback[0] = 0.0;
5858 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5859 yelectboardback[2] = yelectboardback[1];
5860 yelectboardback[3] = yelectboardback[0];
5861 yelectboardback[4] = yelectboardback[3];
5862 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5863 yelectboardback[6] = yelectboardback[5];
5864 yelectboardback[7] = yelectboardback[4];
5865 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5866 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5867 xelectboardback,yelectboardback);
5868 electboardbackshape->DefineSection(0,0.0);
5869 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5870 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5871 electboardbackshape,fSSDSupportRingAl);
5872 electboardback->SetLineColor(fColorAl);
5873 // Electronic Board Kapton Layer
5874 const Int_t kelectlayervertexnumber = 8;
5875 Double_t xelectlayer[kelectlayervertexnumber];
5876 Double_t yelectlayer[kelectlayervertexnumber];
5877 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5878 xelectlayer[1] = xelectlayer[0];
5879 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5880 xelectlayer[3] = xelectlayer[2];
5881 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5882
5883 yelectlayer[0] = 0.0;
5884 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5885 yelectlayer[2] = yelectlayer[1];
5886 yelectlayer[3] = yelectlayer[0];
5887 yelectlayer[4] = yelectlayer[3];
5888 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5889 yelectlayer[6] = yelectlayer[5];
5890 yelectlayer[7] = yelectlayer[4];
5891 TGeoXtru* electlayershape = new TGeoXtru(2);
5892 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5893 electlayershape->DefineSection(0,0.0);
5894 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5895 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5896 electlayershape,fSSDKaptonFlexMedium);
5897 electlayer->SetLineColor(fColorKapton);
5898 // JMD Connector Female
5899 const Int_t kjmdconnectorvertexnumber = 6;
5900 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5901 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5902 xjmdconnectorvertex[0] = 0.0;
5903 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5904 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5905 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5906 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5907 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5908
5909 yjmdconnectorvertex[0] = 0.0;
5910 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5911 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5912 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5913 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5914 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5915 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5916 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5917 yjmdconnectorvertex);
5918 jmdconnectorshape->DefineSection(0,0.0);
5919 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5920 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5921 jmdconnectorshape,fSSDMountingBlockMedium);
5922 jmdconnector->SetLineColor(fColorG10);
5923 // Top Cable Connector
5924 const Int_t kcableconnectorvertexnumber = 8;
5925 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5926 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5927 xconnectorvertex[0] = 0.0;
5928 xconnectorvertex[1] = xconnectorvertex[0];
5929 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5930 xconnectorvertex[3] = xconnectorvertex[2];
5931 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5932 - fgkEndCapCardCableConnectorLength[2];
5933 xconnectorvertex[5] = xconnectorvertex[4];
5934 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5935 xconnectorvertex[7] = xconnectorvertex[6];
5936
5937 yconnectorvertex[0] = 0.0;
5938 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5939 yconnectorvertex[2] = yconnectorvertex[1];
5940 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5941 yconnectorvertex[4] = yconnectorvertex[3];
5942 yconnectorvertex[5] = yconnectorvertex[1];
5943 yconnectorvertex[6] = yconnectorvertex[5];
5944 yconnectorvertex[7] = yconnectorvertex[0];
5945 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5946 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5947 yconnectorvertex);
5948 cableconnectorshape->DefineSection(0,0.0);
5949 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5950 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5951 cableconnectorshape,fSSDMountingBlockMedium);
5952 cableconnector->SetLineColor(fColorG10);
5953 // Strip Connection
5954 TGeoBBox* endcapstripconnectionshape =
5955 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5956 0.5*fgkEndCapStripConnectionThickness,
5957 0.5*fgkEndCapStripConnectionWidth);
5958 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5959 endcapstripconnectionshape,
5960 fSSDSupportRingAl);
5961 endcapstripconnection->SetLineColor(fColorAl);
5962 // Interface Card B
5963 const Int_t kcardBvertexnumber = 12;
5964 Double_t xcardBvertexnumber[kcardBvertexnumber];
5965 Double_t ycardBvertexnumber[kcardBvertexnumber];
5966
5967 xcardBvertexnumber[0] = 0.0;
5968 xcardBvertexnumber[1] = xcardBvertexnumber[0];
5969 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5970 xcardBvertexnumber[3] = xcardBvertexnumber[2];
5971 xcardBvertexnumber[4] = xcardBvertexnumber[1];
5972 xcardBvertexnumber[5] = xcardBvertexnumber[4];
5973 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5974 xcardBvertexnumber[7] = xcardBvertexnumber[6];
5975 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5976 xcardBvertexnumber[9] = xcardBvertexnumber[8];
5977 xcardBvertexnumber[10] = xcardBvertexnumber[7];
5978 xcardBvertexnumber[11] = xcardBvertexnumber[10];
5979
5980 ycardBvertexnumber[0] = 0.0;
5981 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
5982 ycardBvertexnumber[2] = ycardBvertexnumber[1];
5983 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5984 ycardBvertexnumber[4] = ycardBvertexnumber[3];
5985 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5986 ycardBvertexnumber[6] = ycardBvertexnumber[5];
5987 ycardBvertexnumber[7] = ycardBvertexnumber[4];
5988 ycardBvertexnumber[8] = ycardBvertexnumber[7];
5989 ycardBvertexnumber[9] = ycardBvertexnumber[1];
5990 ycardBvertexnumber[10] = ycardBvertexnumber[9];
5991 ycardBvertexnumber[11] = ycardBvertexnumber[0];
5992
5993 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5994 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5995 interfacecardBshape->DefineSection(0,0.);
5996 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5997 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5998 fSSDMountingBlockMedium);
5999 interfacecardB->SetLineColor(46);
6000 // Interface Card B Electronic Board
6001 const Int_t kelectboardcardBvertexnumber = 14;
6002 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
6003 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
6004
6005 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
6006 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
6007 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
6008 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
6009 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
6010 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
6011 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6012 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
6013 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6014 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
6015 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6016 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6017 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6018 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6019
6020 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6021 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6022 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
6023 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6024 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
6025 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
6026 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
6027 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6028 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
6029 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6030 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6031 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6032 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6033 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6034
6035 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6036 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6037 xelectboardcardBvertex,yelectboardcardBvertex);
6038 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6039 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6040 + fgkEndCapInterfaceElectBoardCardBThickness);
6041 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6042 fSSDSupportRingAl);
6043 electboardcardB->SetLineColor(fColorAl);
6044 // Generating Stiffener 2
6045 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6046 0.5*fgkEndCapStiffenerThickness,
6047 0.5*fgkEndCapStiffenerLength);
6048 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6049 endcapstiffener->SetLineColor(fColorAl);
6050 // Generating Mother Interface Card B Container
6051 const Int_t kinterfacecardBmothervertexnumber = 10;
6052 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6053 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6054
6055 xinterfacecardBmothervertex[0] = 0.0;
6056 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6057 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6058 + fgkEndCapInterfaceCardBThickness;
6059 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6060 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6061 + fgkEndCapInterfaceElectBoardCardBThickness;
6062 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6063 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6064 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6065 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6066 + fgkEndCapCardJMDConnectorLength[0];
6067 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6068
6069 yinterfacecardBmothervertex[0] = 0.0;
6070 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6071 + fgkEndCapInterfaceCardBWidth[1]
6072 + fgkEndCapInterfaceCardBWidth[2];
6073 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6074 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6075 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6076 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6077 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6078 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6079 + fgkEndCapCardJMDConnectorWidth[0]
6080 + fgkEndCapCardJMDConnectorWidth[1];
6081 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6082 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6083 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6084 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6085 xinterfacecardBmothervertex,
6086 yinterfacecardBmothervertex);
6087 interfacecardBmothershape->DefineSection(0,-1.e-15);
6088 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6089 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6090 interfacecardBmothershape,fSSDAir);
6091 electboardcardB->SetLineColor(fColorAl);
6092 // Positioning Volumes Mother Interface Card B Container
6093 TGeoRotation* interfacecardBrot = new TGeoRotation();
6094 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6095 interfacecardBrot->SetAngles(90.,-90.,-90.);
6096 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6097 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6098 TGeoRotation* electboardcardBrot = new TGeoRotation();
6099 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6100 electboardcardBrot->SetAngles(90.,90.,-90.);
6101 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6102 TGeoCombiTrans* electboardcardBcombitrans =
6103 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6104 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6105 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6106 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6107 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6108 TGeoTranslation* jmdconnectorcardBtrans[3];
6109 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6110 for(Int_t i=0; i<3; i++){
6111 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6112 + fgkEndCapCardJMDConnectorLength[0],
6113 fgkEndCapCardElectBoardLayerWidth[1],
6114 0.5*fgkEndCapCardJMDConnectorThickness
6115 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6116 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6117 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6118 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6119 *jmdconnectorcardBrot);
6120 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6121 }
6122 // Mother Supply Card Container
6123 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6124 // Interface Card Container
6125 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6126 // Placing Volumes in Mother Supply Card Container
6127 // JMD Connector Positioning
6128 TGeoTranslation* jmdconnectortrans[2];
6129 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6130 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6131 fgkEndCapCardElectBoardBackLength[0]
6132 - fgkEndCapCardJMDConnectorThickness
6133 - fgkEndCapCardJMDConnectorToLayer);
6134 TGeoRotation* jmdconnectorot = new TGeoRotation();
6135 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6136 + 2.*fgkEndCapCardJMDConnectorLength[0]
6137 + 2.*fgkEndCapCardElectBoardLayerThickness,
6138 fgkEndCapCardElectBoardLayerWidth[1],
6139 fgkEndCapCardJMDConnectorThickness
6140 + fgkEndCapCardJMDConnectorToLayer);
6141 jmdconnectorot->SetAngles(90.,180.,-90);
6142 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6143 * jmdconnectorot);
6144 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6145 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6146 // Top Cable Connector Placing
6147 TGeoRotation* cableconnectorot[2];
6148 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6149 TGeoTranslation* cableconnectortrans[3];
6150 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6151 cableconnectorot[0]->SetAngles(90.,0.,0.);
6152 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6153 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6154 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6155 *cableconnectorot[0]);
6156 TGeoHMatrix* cableconnectormatrix[2];
6157 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6158 new TGeoHMatrix((*cableconnectorot[1])
6159 *(*cableconnectorcombitrans));
6160 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6161 - fgkEndCapCardCableConnectorThickness,
6162 fgkEndCapCardCableConnectorLength[0]
6163 + fgkEndCapCardCableConnectorToLayer);
6164 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6165 - 2.*fgkEndCapCardCableConnectorThickness
6166 - fgkEndCapCardCableConnectorDistance,
6167 fgkEndCapCardCableConnectorLength[0]
6168 + fgkEndCapCardCableConnectorToLayer);
6169 for(Int_t i=0; i<2; i++){
6170 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6171 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6172 }
6173 TGeoRotation* electboardbackrot = new TGeoRotation();
6174 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6175 electboardbackrot->SetAngles(90.,-90.,-90.);
6176 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6177 + fgkEndCapCardJMDConnectorLength[0]
6178 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6179 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6180 *electboardbackrot);
6181 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6182 // Electronic Board Kapton Layer Positioning
6183 TGeoRotation* electlayerrot = new TGeoRotation();
6184 TGeoTranslation* electlayertrans[2];
6185 TGeoCombiTrans* electlayercombitrans[2];
6186 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6187 electlayerrot->SetAngles(90.,-90.,-90.);
6188 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6189 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6190 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6191 + 2.*fgkEndCapCardElectBoardLayerThickness
6192 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6193 for(Int_t i=0; i<2; i++){
6194 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6195 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6196 }
6197 // Placing Volumes in Mother Interface Card Container
6198 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6199 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6200 for(Int_t i=0; i<2; i++){
6201 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6202 }
6203 /////////////////////////////////////////////////////////////
6204 // Generation of Card Interface Container
6205 /////////////////////////////////////////////////////////////
6206 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6207 - fgkEndCapCardJMDConnectorLength[0]
6208 - fgkEndCapInterfaceCardBThickness
6209 - 9.*fgkEndCapStripConnectionThickness
6210 - 8.*fgkEndCapCardElectBoardBackThickness;
6211 const Int_t kcardinterfacecontainervertexnumber = 14;
6212 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6213 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6214 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6215 - 7.0*fgkEndCapStripConnectionThickness;
6216 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6217 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6218 + fgkEndCapStripConnectionThickness
6219 - fgkEndCapCardElectBoardLayerThickness
6220 - fgkEndCapCardCableConnectorWidth[0];
6221 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6222 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6223 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6224 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6225 + 2.0*fgkEndCapStripConnectionThickness;
6226 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6227 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6228 + fgkEndCapInterfaceCardBThickness;
6229 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6230 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6231 + fgkEndCapInterfaceElectBoardCardBThickness;
6232 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6233 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6234 - fgkEndCapInterfaceElectBoardCardBThickness
6235 + fgkEndCapCardJMDConnectorLength[0]
6236 + stiffenertransx+fgkEndCapStiffenerWidth;
6237 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6238
6239 ycardinterfacecontainervertex[0] = 0.;
6240 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6241 + fgkEndCapCardJMDConnectorWidth[0]
6242 + fgkEndCapCardJMDConnectorWidth[1];
6243 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6244 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6245 - fgkEndCapStripConnectionWidth;
6246 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6247 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6248 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6249 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6250 + fgkEndCapInterfaceCardBWidth[1]
6251 + fgkEndCapInterfaceCardBWidth[2];
6252 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6253 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6254 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6255 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6256 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6257 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6258
6259 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6260 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6261 xcardinterfacecontainervertex,
6262 ycardinterfacecontainervertex);
6263 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6264 - fgkEndCapCardElectBoardBackLength[0]));
6265 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6266 + fgkEndCapCardElectBoardBackLength[0]));
6267 TGeoVolume** cardinterfacecontainer;
6268 cardinterfacecontainer = new TGeoVolume*[4];
6269 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6270 interfacecardmothershape,fSSDAir);
6271 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6272 interfacecardmothershape,fSSDAir);
6273 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6274 interfacecardmothershape,fSSDAir);
6275 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6276 interfacecardmothershape,fSSDAir);
6277 /////////////////////////////////
6278 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6279 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6280 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6281 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6282 /////////////////////////////////
6283 TGeoRotation* endcapstripconnectionrot[2];
6284 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6285 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6286 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6287 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6288 * (*endcapstripconnectionrot[0]));
6289 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6290 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6291 -0.5*fgkEndCapCardElectBoardBackThickness,
6292 fgkEndCapCardElectBoardBackWidth[0]
6293 -endcapstripconnectionshape->GetDZ(),
6294 0.5*fgkEndCapCardElectBoardBackLength[0]);
6295 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6296 TGeoTranslation* cardinterfacetrans[9];
6297 TGeoHMatrix* cardinterfacematrix[9];
6298 for(Int_t i=0; i<7; i++){
6299 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6300 + fgkEndCapCardElectBoardBackThickness),
6301 0.0,0.0);
6302 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6303 * (*endcapstripconnectionmatrix));
6304 }
6305 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6306 + fgkEndCapCardElectBoardBackThickness),
6307 0.0,0.0);
6308 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6309 * (*endcapstripconnectionmatrix));
6310 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6311 + fgkEndCapCardElectBoardBackThickness),
6312 0.0,0.0);
6313 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6314 * (*endcapstripconnectionmatrix));
6315
6316 for(Int_t i=0; i<4; i++){
6317 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6318 cardinterfacematrix[7]);
6319 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6320 cardinterfacematrix[8]);
6321 }
6322 TGeoTranslation* mothersupplycardtrans =
6323 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6324 + 2.*fgkEndCapCardJMDConnectorLength[0]
6325 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6326 TGeoHMatrix* mothersupplycardmatrix[7];
6327 Int_t index[4] = {1,1,1,1};
6328 for(Int_t i=0; i<7; i++){
6329 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6330 * (*mothersupplycardtrans));
6331 for(Int_t j=0; j<4; j++){
6332 switch(j){
6333 case 0: //Layer5 EndCap Left Side
6334 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6335 cardinterfacematrix[i]);
6336 if(i!=0){
6337 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6338 mothersupplycardmatrix[i]);
6339 index[j]++;
6340
6341 }
6342 break;
6343 case 1: //Layer5 EndCap Rigth Side
6344 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6345 cardinterfacematrix[i]);
6346 if(i>0&&i<6){
6347 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6348 mothersupplycardmatrix[i]);
6349 index[j]++;
6350 }
6351 break;
6352 case 2: //Layer6 EndCap Left Side
6353 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6354 cardinterfacematrix[i]);
6355 if(i!=6){
6356 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6357 mothersupplycardmatrix[i]);
6358 index[j]++;
6359 }
6360 break;
6361 case 3: //Layer6 EndCap Right Side
6362 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6363 cardinterfacematrix[i]);
6364 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6365 mothersupplycardmatrix[i]);
6366 index[j]++;
6367 break;
6368 }
6369 }
6370 }
6371 // Positioning Interface
6372 TGeoTranslation* motherinterfacecardtrans =
6373 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6374 +0.5*fgkEndCapCardElectBoardBackThickness
6375 -fgkEndCapCardElectBoardLayerThickness
6376 +fgkEndCapStripConnectionThickness,0.,0.);
6377 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6378 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6379 // Positioning Interface Card B
6380 TGeoTranslation* interfacecardBmothertrans =
6381 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6382 + 2.*fgkEndCapStripConnectionThickness
6383 + fgkEndCapCardElectBoardBackThickness,0.,
6384 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6385 - fgkEndCapCardElectBoardBackLength[0]));
6386 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6387 interfacecardBmothertrans);
6388 // Positioning Stiffener
6389 TGeoTranslation* endcapstiffenertrans =
6390 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6391 + 2.0*fgkEndCapStripConnectionThickness
6392 + fgkEndCapInterfaceCardBThickness
6393 + fgkEndCapCardJMDConnectorLength[0]
6394 + stiffenertransx
6395 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6396 endcapstiffenershape->GetDZ()
6397 - 0.5*(fgkEndCapStiffenerLength
6398 - fgkEndCapCardElectBoardBackLength[0]));
6399 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6400 /////////////////////////////////////////////////////////////
6401 // Deallocating memory
6402 /////////////////////////////////////////////////////////////
6403 delete interfacecardBrot;
6404 delete interfacecardBtrans;
6405 delete electboardcardBtrans;
6406 delete electboardcardBrot;
6407 delete jmdconnectorcardBrot;
6408 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6409 delete jmdconnectorot;
6410 delete jmdconnectortrans[1];
6411 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6412 delete cableconnectorcombitrans;
6413 delete electboardbacktrans;
6414 delete electboardbackrot;
6415 delete electlayerrot;
6416 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6417 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6418 delete mothersupplycardtrans;
6419 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6420 /////////////////////////////////////////////////////////////
6421 return cardinterfacecontainer;
6422 }
6423 ////////////////////////////////////////////////////////////////////////////////
6424 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6425 /////////////////////////////////////////////////////////////
6426 // Method returning EndCap Mother Volume
6427 /////////////////////////////////////////////////////////////
6428 const Int_t kendcapcoverplatesmallholenumber = 9;
6429 Double_t endcapmotherorigin[3];
6430 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6431 + 0.5 *(fgkEndCapCoverPlateLength[3]
6432 + 2.0 * fgkEndCapCoverPlateLength[2]);
6433 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6434 - fgkEndCapCoverPlateWidth[2]
6435 - (kendcapcoverplatesmallholenumber-1)
6436 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6437 + 0.5*(fgkEndCapSideCoverLength[2]
6438 + fgkEndCapCoverPlateWidth[1]
6439 - fgkEndCapCoverPlateWidth[0])
6440 - (fgkEndCapCoverPlateWidth[1]
6441 - fgkEndCapCoverPlateWidth[0]);
6442 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6443 + 2.*fgkEndCapCoolingTubeRadiusMax
6444 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6445 + fgkEndCapSideCoverWidth[1]
6446 + fgkEndCapSideCoverThickness
6447 + fgkEndCapKaptonFoilThickness);
6448 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6449 + 2.0* fgkEndCapCoverPlateLength[2]
6450 + 2.0* fgkEndCapSideCoverThickness),
6451 0.5* (fgkEndCapSideCoverLength[2]
6452 + fgkEndCapCoverPlateWidth[1]
6453 - fgkEndCapCoverPlateWidth[0]),
6454 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6455 + fgkEndCapSideCoverWidth[1]
6456 + fgkEndCapSideCoverThickness
6457 + fgkEndCapKaptonFoilThickness),
6458 endcapmotherorigin);
6459 TGeoVolume** endcapassembly;
6460 endcapassembly = new TGeoVolume*[4];
6461 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6462 endcapmothershape,fSSDAir);
6463 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6464 endcapmothershape,fSSDAir);
6465 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6466 endcapmothershape,fSSDAir);
6467 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6468 endcapmothershape,fSSDAir);
6469 /////////////////////////////////
6470 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6471 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6472 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6473 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6474 /////////////////////////////////
6475 /////////////////////////////////////////////////////
6476 // Placing Endcap Cover Plate
6477 /////////////////////////////////////////////////////
6478 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6479 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6480 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6481 TGeoCombiTrans* endcapcoverplatecombitrans =
6482 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6483 endcapcoverplaterot);
6484 TGeoTranslation* endcapcoverplatetrans =
6485 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6486 TGeoHMatrix* endcapcoverplatematrix =
6487 new TGeoHMatrix((*endcapcoverplatetrans)
6488 * (*endcapcoverplatecombitrans));
6489 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6490 /////////////////////////////////////////////////////
6491 // Placing Endcap Side Cover
6492 /////////////////////////////////////////////////////
6493 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6494 TGeoRotation* endcapsidecoverot[2];
6495 TGeoCombiTrans* endcapsidecovercombitrans[3];
6496 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6497 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6498 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6499 - 0.5*(fgkEndCapCoverPlateWidth[0]
6500 - fgkEndCapCoverPlateWidth[2]
6501 - (kendcapcoverplatesmallholenumber-1)
6502 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6503 + 0.*fgkEndCapCoverPlateWidth[0]
6504 + fgkEndCapSideCoverLength[2],
6505 0.5*(fgkEndCapSideCoverThickness
6506 + fgkEndCapCoverPlateThickness)
6507 - 0.5*fgkEndCapCoverPlateThickness,
6508 endcapsidecoverot[0]);
6509 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6510 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6511 0.5*fgkEndCapCoverPlateThickness
6512 -fgkEndCapSideCoverWidth[1],
6513 endcapsidecoverot[1]);
6514 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6515 +fgkEndCapCoverPlateLength[3]
6516 +2.*fgkEndCapCoverPlateLength[2]
6517 +fgkEndCapSideCoverThickness,0.0,
6518 0.5*fgkEndCapCoverPlateThickness
6519 -fgkEndCapSideCoverWidth[1],
6520 endcapsidecoverot[1]);
6521 TGeoHMatrix* endcapsidecovermatrix[2];
6522 for(Int_t i=0; i<2; i++){
6523 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6524 * (*endcapsidecovercombitrans[0]));
6525 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6526 endcapsidecovermatrix[i]);
6527 }
6528 /////////////////////////////////////////////////////
6529 // Placing Endcap Cooling Tube
6530 /////////////////////////////////////////////////////
6531 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6532 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6533 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6534 TGeoCombiTrans* endcapccolingtubecombitrans
6535 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6536 + fgkEndCapCoolingTubeAxialRadius[1])
6537 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6538 - fgkEndCapCoolingTubeToCoverSide,
6539 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6540 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6541 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6542 endcapccolingtubecombitrans);
6543 /////////////////////////////////////////////////////
6544 // Placing Screws
6545 /////////////////////////////////////////////////////
6546 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6547 fgkEndCapCoverPlateScrewRadiusMin};
6548 Int_t screwcoverplatedgesnumber[2] = {20,20};
6549 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6550 fgkEndCapCoverPlateThickness
6551 + fgkEndCapCoolingTubeRadiusMax};
6552 TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6553 screwcoverplatedgesnumber,
6554 screwcoverplatesection);
6555 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6556 screwcoverplateshape,
6557 fSSDCoolingTubePhynox);
6558 screwcoverplate->SetLineColor(12);
6559 Double_t transx[4] = {0,
6560 fgkEndCapCoverPlateSmallHoleSeparation[0],
6561 fgkEndCapCoverPlateSmallHoleSeparation[0]
6562 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6563 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6564 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6565 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6566// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6567 TGeoTranslation*** endcapcoverplatescrewtrans;
6568 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6569 Int_t index = 0;
6570 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6571 endcapcoverplatescrewtrans[i] =
6572 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6573 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6574 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6575 if(index==1||index==9||index==28||index==36){
6576 endcapcoverplatescrewtrans[i][j] =
6577 new TGeoTranslation(transx[i],
6578 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6579 fgkEndCapSideCoverThickness);
6580 }
6581 else{
6582 endcapcoverplatescrewtrans[i][j] =
6583 new TGeoTranslation(transx[i],
6584 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6585 0.);
6586 }
6587 if(index!=19)
6588 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6589 endcapcoverplatescrewtrans[i][j]);
6590 }
6591 }
6592 /////////////////////////////////////////////////////
6593 // Placing Cover Plate Clips
6594 /////////////////////////////////////////////////////
6595 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6596 0.5*fgkEndCapCoverPlateClipWidth,
6597 0.5*fgkEndCapSideCoverThickness);
6598 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6599 endcapcoverplateclipshape,
6600 fSSDCoolingTubePhynox);
6601 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6602 0.5*fgkEndCapCoverPlateDownClipWidth,
6603 0.5*fgkEndCapSideCoverThickness);
6604 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6605 endcapcoverplatedownclipshape,
6606 fSSDCoolingTubePhynox);
6607 TGeoTranslation* endcapcoverplatecliptrans[4];
6608 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6609 - fgkEndCapCoverPlateLength[0]
6610 - fgkEndCapSideCoverThickness,
6611 0.0,
6612 0.5*(fgkEndCapSideCoverThickness
6613 + fgkEndCapCoverPlateThickness));
6614 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6615 - fgkEndCapCoverPlateLength[0]
6616 - fgkEndCapSideCoverThickness,
6617 (kendcapcoverplatescrewnumber[1]-1)
6618 * fgkEndCapSideCoverWidth[5],
6619 0.5*(fgkEndCapSideCoverThickness
6620 + fgkEndCapCoverPlateThickness));
6621 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6622 - fgkEndCapCoverPlateLength[0]
6623 + fgkEndCapCoverPlateLength[1]
6624 + 2.*fgkEndCapCoverPlateLength[0]
6625 - fgkEndCapCoverPlateClipLength
6626 + fgkEndCapSideCoverThickness,
6627 0.0,
6628 0.5*(fgkEndCapSideCoverThickness
6629 + fgkEndCapCoverPlateThickness));
6630 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6631 - fgkEndCapCoverPlateLength[0]
6632 + fgkEndCapCoverPlateLength[1]
6633 + 2.*fgkEndCapCoverPlateLength[0]
6634 - fgkEndCapCoverPlateClipLength
6635 + fgkEndCapSideCoverThickness,
6636 (kendcapcoverplatescrewnumber[1]-1)
6637 * fgkEndCapSideCoverWidth[5],
6638 0.5*(fgkEndCapSideCoverThickness
6639 + fgkEndCapCoverPlateThickness));
6640 endcapcoverplateclip->SetLineColor(fColorPhynox);
6641 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6642 for(Int_t i=0; i<4; i++)
6643 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6644 endcapcoverplatecliptrans[i]);
6645 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6646 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6647 - fgkEndCapCoverPlateLength[0]
6648 - fgkEndCapSideCoverThickness,
6649 0.5*(fgkEndCapCoverPlateDownClipWidth
6650 - fgkEndCapCoverPlateClipWidth),
6651 0.5*(fgkEndCapSideCoverThickness
6652 + fgkEndCapCoverPlateThickness)
6653 - fgkEndCapSideCoverWidth[1]
6654 - fgkEndCapSideCoverThickness);
6655 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6656 - fgkEndCapCoverPlateLength[0]
6657 - fgkEndCapSideCoverThickness,
6658 0.5*(fgkEndCapCoverPlateDownClipWidth
6659 - fgkEndCapCoverPlateClipWidth)
6660 + fgkEndCapSideCoverLength[2]
6661 - fgkEndCapCoverPlateDownClipWidth,
6662 0.5*(fgkEndCapSideCoverThickness
6663 + fgkEndCapCoverPlateThickness)
6664 - fgkEndCapSideCoverWidth[1]
6665 - fgkEndCapSideCoverThickness);
6666 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6667 - fgkEndCapCoverPlateLength[0]
6668 + fgkEndCapSideCoverThickness
6669 + fgkEndCapCoverPlateLength[1]
6670 + 2.0*fgkEndCapCoverPlateLength[0]
6671 - fgkEndCapCoverPlateDownClipLength,
6672 0.5*(fgkEndCapCoverPlateDownClipWidth
6673 - fgkEndCapCoverPlateClipWidth),
6674 0.5*(fgkEndCapSideCoverThickness
6675 + fgkEndCapCoverPlateThickness)
6676 - fgkEndCapSideCoverWidth[1]
6677 - fgkEndCapSideCoverThickness);
6678 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6679 - fgkEndCapCoverPlateLength[0]
6680 + fgkEndCapSideCoverThickness
6681 + fgkEndCapCoverPlateLength[1]
6682 + 2.0*fgkEndCapCoverPlateLength[0]
6683 - fgkEndCapCoverPlateDownClipLength,
6684 0.5*(fgkEndCapCoverPlateDownClipWidth
6685 - fgkEndCapCoverPlateClipWidth)
6686 + fgkEndCapSideCoverLength[2]
6687 - fgkEndCapCoverPlateDownClipWidth,
6688 0.5*(fgkEndCapSideCoverThickness
6689 + fgkEndCapCoverPlateThickness)
6690 - fgkEndCapSideCoverWidth[1]
6691 - fgkEndCapSideCoverThickness);
6692 for(Int_t i=0; i<4; i++)
6693 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6694 endcapcoverplatedowncliptrans[i]);
6695 /////////////////////////////////////////////////////
6696 // Placing Kapton Foil
6697 /////////////////////////////////////////////////////
6698 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6699 0.5*fgkEndCapKaptonFoilWidth,
6700 0.5*fgkEndCapKaptonFoilThickness);
6701 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6702 endcapkaptonfoilshape,
6703 fSSDKaptonFlexMedium);
6704 endcapkaptonfoil->SetLineColor(8);
6705 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6706 0.5*fgkEndCapKaptonFoilWidth
6707 - 0.5*fgkEndCapCoverPlateClipWidth,
6708 0.5*fgkEndCapCoverPlateThickness
6709 - 0.5*fgkEndCapKaptonFoilThickness
6710 - fgkEndCapSideCoverWidth[1]
6711 - fgkEndCapSideCoverThickness);
6712 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6713 /////////////////////////////////////////////////////////////
6714 // Placing Electronic Tubes
6715 /////////////////////////////////////////////////////////////
6716 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6717 - fgkEndCapInterfaceCardBThickness
6718 - 9.*fgkEndCapStripConnectionThickness
6719 - 8.*fgkEndCapCardElectBoardBackThickness,
6720 fgkEndCapKaptonFoilWidth
6721 - fgkEndCapInterfaceCardBThickness
6722 - 9.*fgkEndCapStripConnectionThickness
6723 - 8.*fgkEndCapCardElectBoardBackThickness
6724 - fgkEndCapInterfaceElectBoardCardBThickness};
6725 TGeoVolume* endcapeffectivecables[2];
6726 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6727 fgkEndCapEffectiveCableRadiusMax,
6728 endcapeffectivecableswidth[0],
6729 10,"EndCapEffectiveCables1");
6730 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6731 fgkEndCapEffectiveCableRadiusMax,
6732 endcapeffectivecableswidth[1],
6733 25,"EndCapEffectiveCables2");
6734 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6735 TGeoTranslation* endcapeffectivecablestrans[2];
6736 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6737 - 0.5*endcapeffectivecableswidth[0]
6738 - 0.5*(fgkEndCapCoverPlateWidth[0]
6739 - fgkEndCapCoverPlateWidth[2]
6740 - (kendcapcoverplatesmallholenumber-1)
6741 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6742 + fgkEndCapSideCoverLength[2],
6743 - 0.5*fgkEndCapCoverPlateThickness
6744 - (fgkEndCapCardElectBoardBackWidth[0]
6745 - fgkEndCapInterfaceCardBWidth[0]
6746 - fgkEndCapInterfaceCardBWidth[1]));
6747 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6748 - 0.5*endcapeffectivecableswidth[1]
6749 - 0.5*(fgkEndCapCoverPlateWidth[0]
6750 - fgkEndCapCoverPlateWidth[2]
6751 - (kendcapcoverplatesmallholenumber-1)
6752 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6753 + fgkEndCapSideCoverLength[2],
6754 - 0.5*fgkEndCapCoverPlateThickness
6755 - (fgkEndCapCardElectBoardBackWidth[0]
6756 - fgkEndCapInterfaceCardBWidth[0])
6757 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6758 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6759 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6760 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6761 *endcapeffectivecablesrot);
6762 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6763 *endcapeffectivecablesrot);
6764 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6765 endcapeffectivecablescombitrans[0]);
6766 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6767 endcapeffectivecablescombitrans[1]);
6768 /////////////////////////////////////////////////////////////
6769 // Placing End Cap Cards
6770 /////////////////////////////////////////////////////////////
6771 TGeoVolume** endcapcards = GetEndCapCards();
6772 TGeoRotation* endcapcardsrot[2];
6773 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6774 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6775 TGeoTranslation* endcapcardstrans[2];
6776 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6777 - fgkEndCapCardElectBoardBackLength[0]));
6778 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6779 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6780 TGeoHMatrix* endcapcardsmatrix[2];
6781 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6782 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6783 - fgkEndCapCardJMDConnectorLength[0]
6784 - fgkEndCapInterfaceCardBThickness
6785 - 9.*fgkEndCapStripConnectionThickness
6786 - 8.*fgkEndCapCardElectBoardBackThickness;
6787 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6788 - fgkEndCapCoverPlateLength[0]
6789 + 0.5 * (fgkEndCapCoverPlateLength[3]
6790 + 2.0 * fgkEndCapCoverPlateLength[2]),
6791 - stiffenertransx-fgkEndCapStiffenerWidth
6792 - fgkEndCapCardJMDConnectorLength[0]
6793 - fgkEndCapInterfaceCardBThickness
6794 - 2.0 * fgkEndCapStripConnectionThickness
6795 - 1.5 * fgkEndCapInterfaceCardBThickness
6796 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6797 - fgkEndCapCoverPlateWidth[2]
6798 - (kendcapcoverplatesmallholenumber-1)
6799 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6800 + fgkEndCapKaptonFoilWidth,
6801 0.5*fgkEndCapCoverPlateThickness
6802 - fgkEndCapSideCoverWidth[1]);
6803 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6804 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6805 /////////////////////////////////////////////////////////////
6806 // Deallocating memory
6807 /////////////////////////////////////////////////////////////
6808 delete endcapcoverplaterot;
6809 delete endcapcoverplatecombitrans;
6810 delete endcapcoverplatetrans;
6811 for(Int_t i=0; i<3; i++){
6812 delete endcapsidecovercombitrans[i];
6813 if(i<2) delete endcapsidecoverot[i];
6814 }
6815 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6816 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6817 delete endcapcardsmatrix[0];
6818 return endcapassembly;
6819 }
6820 ////////////////////////////////////////////////////////////////////////////////
6821 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6822 Double_t radiusmax,
6823 Double_t width,
6824 Int_t ncables,
6825 char* volname){
6826 /////////////////////////////////////////////////////////////
6827 // Generating EndCap High Voltage Tubes
6828 /////////////////////////////////////////////////////////////
6829 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6830 Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.)
6831 + TMath::Power(radiusmax,2.)
6832 - TMath::Power(radiusmin,2.));
6833 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6834 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6835 effectiveouteradius,0.5*width);
6836 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6837 effectiveinnertubeshape,
6838 fSSDStiffenerConnectorMedium);
6839 effectiveinnertube->SetLineColor(41);
6840 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6841 effectiveoutertubeshape,
6842 fSSDKaptonChipCableMedium);
6843 effectiveoutertube->SetLineColor(39);
6844 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6845 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6846 effectivemothertube->AddNode(effectiveinnertube,1);
6847 effectivemothertube->AddNode(effectiveoutertube,1);
6848 return effectivemothertube;
6849 }
6850 ////////////////////////////////////////////////////////////////////////////////
6851 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6852 /////////////////////////////////////////////////////////////
6853 // Generating EndCap Support Layer 5 and Layer 6
6854 /////////////////////////////////////////////////////////////
6855 const Int_t knedges = 5;
6856 ///////////////////////////////////////////////
6857 // Setting the vertices for TGeoXtru Up Volume
6858 ///////////////////////////////////////////////
6859 const Int_t klayernumber = 2;
6860 Double_t xupvertex[klayernumber][knedges+3];
6861 Double_t yupvertex[klayernumber][knedges+3];
6862 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6863 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6864 Double_t middlepsi[klayernumber] = {0.0,0.0};
6865 for(Int_t i=0; i<klayernumber; i++){
6866 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6867 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6868 xupvertex[i][2] = -xupvertex[i][1];
6869 xupvertex[i][3] = -xupvertex[i][0];
6870
6871 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6872 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6873 yupvertex[i][2] = yupvertex[i][1];
6874 yupvertex[i][3] = yupvertex[i][0];
6875
6876 middledgeangle[i] = upedgeangle[i]/knedges;
6877 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6878 for(Int_t j=1; j<knedges; j++){
6879 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6880 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6881 }
6882 }
6883 ////////////////////////////////////
6884 // Generating Up TGeoXtru
6885 ////////////////////////////////////
6886 TGeoXtru* upendcapsupportshape[klayernumber];
6887 TGeoVolume* upendcapsupport[klayernumber];
6888 char upendcapsupportname[30];
6889 for(Int_t i=0; i<klayernumber; i++){
6890 upendcapsupportshape[i] = new TGeoXtru(2);
6891 sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6892 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6893 upendcapsupportshape[i]->DefineSection(0,0.);
6894 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6895 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 6896 fSSDSupportRingAl);
9b0c60ab 6897 upendcapsupport[i]->SetLineColor(5);
6898 }
6899 ///////////////////////////////////////////////
6900 // Setting the vertices for TGeoXtru Down Volume
6901 ///////////////////////////////////////////////
6902 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6903 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6904 for(Int_t i=0; i<klayernumber; i++){
6905 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6906 xdownvertex[i][1] = xupvertex[i][0];
6907 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6908 ydownvertex[i][1] = yupvertex[i][0];
6909 for(Int_t j=0; j<knedges; j++){
6910 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6911 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6912 }
6913 for(Int_t j=0; j<knedges; j++){
6914 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6915 * CosD(middlepsi[i]+j*middledgeangle[i]);
6916 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6917 * SinD(middlepsi[i]+j*middledgeangle[i]);
6918 }
6919 }
6920 ////////////////////////////////////
6921 // Generating Down TGeoXtru
6922 ////////////////////////////////////
6923 TGeoXtru* downendcapsupportshape[klayernumber];
6924 TGeoVolume* downendcapsupport[klayernumber];
6925 char downendcapsupportname[30];
6926 for(Int_t i=0; i<klayernumber; i++){
6927 downendcapsupportshape[i] = new TGeoXtru(2);
6928 sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
6929 downendcapsupportshape[i] = new TGeoXtru(2);
6930 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6931 if(i==0){
6932 downendcapsupportshape[i]->DefineSection(0,0.);
6933 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6934 }
6935 else{
6936 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6937 - fgkEndCapSupportLowWidth[i]);
6938 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6939 }
6940 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 6941 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 6942 downendcapsupport[i]->SetLineColor(5);
6943 }
6944 ///////////////////////////////////////////////
6945 // Setting TGeoPgon Volume
6946 ///////////////////////////////////////////////
6947 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6948 fgkSSDLay6LadderNumber};
6949 TGeoPgon* endcapsupportmothershape[klayernumber];
6950 TGeoVolume** endcapsupportmother;
6951 endcapsupportmother = new TGeoVolume*[klayernumber];
6952 char endcapsupportmothername[30];
6953 for(Int_t i=0; i<klayernumber; i++){
6954 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6955 sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
6956 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6957 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6958 ydownvertex[i][0],yupvertex[i][1]);
6959 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 6960 fSSDAir);
9b0c60ab 6961 }
6962 ////////////////////////////////////
6963 TGeoRotation** endcapsupportrot[klayernumber];
6964 for(Int_t i=0; i<2; i++){
6965 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6966 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6967 endcapsupportrot[i][j] = new TGeoRotation();
6968 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6969 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6970 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6971 }
6972 }
6973 return endcapsupportmother;
6974 }
6975 ////////////////////////////////////////////////////////////////////////////////
6976 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6977 /////////////////////////////////////////////////////////////
6978 // Setting End Cap Support Layer 5 and 6.
6979 /////////////////////////////////////////////////////////////
6980 const Int_t kendcapcoverplatesmallholenumber = 9;
6981 const Int_t klayernumber = 2;
6982 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6983 fgkSSDLay6LadderNumber};
6984 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6985 360.0/kssdlayladdernumber[1]};
6986 TGeoVolume** endcapsupport = EndCapSupport();
6987 TGeoVolume** endcapassembly = GetEndCapAssembly();
6988 TGeoPgon* endcapsupportshape[klayernumber];
6989 Double_t* radiusmin[klayernumber];
6990 Double_t* radiusmax[klayernumber];
6991 for(Int_t i=0; i<klayernumber; i++){
6992 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6993 radiusmin[i] = endcapsupportshape[i]->GetRmin();
6994 radiusmax[i] = endcapsupportshape[i]->GetRmax();
6995 }
6996 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6997 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6998 endcapassemblyshape->GetDY(),
6999 endcapassemblyshape->GetDZ()};
7000 ///////////////////////////////////////////////
7001 // Setting TGeoPgon Volume for Mother Container
7002 ///////////////////////////////////////////////
7003 TGeoPgon* endcapsupportsystemshape[klayernumber];
7004 char endcapsupportsystemothername[30];
7005 for(Int_t i=0; i<klayernumber; i++){
7006 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7007 sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
7008 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
7009 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
7010 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7011 +2.*endcapassemblycenter[2])
7012 /CosD(0.5*upedgeangle[i]));
7013 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7014 -(fgkEndCapCoverPlateWidth[1]
7015 - fgkEndCapCoverPlateWidth[0]),
7016 *radiusmin[i],
7017 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7018 +2.*endcapassemblycenter[2])
7019 /CosD(0.5*upedgeangle[i]));
7020 }
e5bf64ae 7021 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 7022 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7023 endcapsupportsystemshape[0],fSSDAir);
7024 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7025 endcapsupportsystemshape[0],fSSDAir);
7026 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7027 endcapsupportsystemshape[1],fSSDAir);
7028 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7029 endcapsupportsystemshape[1],fSSDAir);
7030 ///////////////////////////////////////////////
7031 TGeoTranslation* endcapassemblytrans[klayernumber];
7032 for(Int_t i=0; i<klayernumber; i++)
7033 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7034 - fgkEndCapSideCoverThickness
7035 + endcapassemblycenter[0],
7036 - 0.5*fgkEndCapCoverPlateThickness
7037 - 2.0*fgkEndCapCoolingTubeRadiusMax
7038 + 2.0*endcapassemblycenter[2]
7039 + 0.5*fgkEndCapSupportLength[i]
7040 / TanD(0.5*upedgeangle[i]),
7041 0.5*(fgkEndCapCoverPlateWidth[0]
7042 - fgkEndCapCoverPlateWidth[2]
7043 - (kendcapcoverplatesmallholenumber-1)
7044 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
7045 TGeoRotation** endcapassemblyrot[klayernumber];
7046 TGeoHMatrix** endcapassemblymatrix[klayernumber];
7047 for(Int_t i=0; i<klayernumber; i++){
7048 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7049 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7050 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7051 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7052 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7053 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7054 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7055 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7056 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7057 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7058 }
7059 }
7060 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7061 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7062 for(Int_t i=0; i<2*klayernumber; i++){
7063 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7064 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7065 endcapassemblymatrix[1][j+2]);
7066 }
7067 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7068 }
7069 /////////////////////////////////////////////////////////////
7070 // Deallocating memory
7071 /////////////////////////////////////////////////////////////
7072 for(Int_t i=0; i<klayernumber; i++){
7073 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7074 delete endcapassemblyrot[i][j];
7075 }
7076 delete endcapassemblyrot[i];
7077 delete endcapassemblymatrix[i][0];
7078 delete endcapassemblymatrix[i][1];
7079 }
7080 /////////////////////////////////////////////////////////////
7081 }
7082 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7083 /////////////////////////////////////////////////////////////
7084 // Setting End Cap Support + End Cap Assembly of Layer 5.
7085 /////////////////////////////////////////////////////////////
7086 if (! moth) {
7087 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, mother is null!\n");
7088 return;
7089 };
e5bf64ae 7090 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7091 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7092 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7093 fgkEndCapSupportCenterLay5ITSPosition
7094 + fgkEndCapSupportCenterLay5Position
7095 - fgkEndCapSideCoverLength[2]);
7096 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7097 fgkEndCapSideCoverLength[2]
7098 - fgkEndCapSupportCenterLay5Position
7099 - fgkEndCapSupportCenterLay5ITSPosition);
7100 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7101 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7102 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7103 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7104 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7105 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7106 /////////////////////////////////////////////////////////////
7107 // Deallocating memory
7108 /////////////////////////////////////////////////////////////
7109 delete endcapsupportsystemrot;
7110 delete endcapsupportsystemITSCentertrans[1];
7111 }
7112 /////////////////////////////////////////////////////////////
7113 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7114 /////////////////////////////////////////////////////////////
7115 // Setting End Cap Support + End Cap Assembly of Layer 6.
7116 /////////////////////////////////////////////////////////////
7117 if (! moth) {
7118 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
7119 return;
7120 };
e5bf64ae 7121 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7122 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7123 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7124 fgkEndCapSupportCenterLay6ITSPosition
7125 + fgkEndCapSupportCenterLay6Position
7126 - fgkEndCapSideCoverLength[2]);
7127 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7128 fgkEndCapSideCoverLength[2]
7129 - fgkEndCapSupportCenterLay6Position
7130 - fgkEndCapSupportCenterLay6ITSPosition);
7131 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7132 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7133 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7134 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7135 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7136 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7137 /////////////////////////////////////////////////////////////
7138 // Deallocating memory
7139 /////////////////////////////////////////////////////////////
7140 delete endcapsupportsystemrot;
7141 delete endcapsupportsystemITSCentertrans[1];
7142 }
7143 ////////////////////////////////////////////////////////////////////////////////
7144 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7145 /////////////////////////////////////////////////////////////
7146 // Setting Ladder Support of Layer 5.
7147 /////////////////////////////////////////////////////////////
7148 if (! moth) {
7149 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
7150 return;
7151 };
7152 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7153 fMotherVol = moth;
7154 TGeoTranslation* centerITSRingSupportLay5trans[2];
7155 for(Int_t i=0; i<2; i++){
7156 centerITSRingSupportLay5trans[i] =
7157 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7158 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7159 }
7160 }
7161 ////////////////////////////////////////////////////////////////////////////////
7162 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7163 /////////////////////////////////////////////////////////////
7164 // Setting Ladder Support of Layer 6.
7165 /////////////////////////////////////////////////////////////
7166 if (! moth) {
7167 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
7168 return;
7169 };
7170 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7171 fMotherVol = moth;
7172 TGeoTranslation* centerITSRingSupportLay6trans[2];
7173 for(Int_t i=0; i<2; i++){
7174 centerITSRingSupportLay6trans[i] =
7175 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7176 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7177 }
7178 }
7179 ////////////////////////////////////////////////////////////////////////////////
d7599219 7180TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
44285dfa 7181 Double_t height, char* shapename, Int_t isign) const{
7182 /////////////////////////////////////////////////////////////
7183 // Method generating an Arb shape
7184 /////////////////////////////////////////////////////////////
7185 const Int_t kvertexnumber = 8;
7186 const Int_t ktransvectnumber = 2;
7187 TVector3* vertex[kvertexnumber];
7188 TVector3* transvector[2];
7189 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
7190 /////////////////////////////////////////////////////////////
d7599219 7191 //Setting the vertices for TGeoArb8
44285dfa 7192 /////////////////////////////////////////////////////////////
7193 vertex[0] = new TVector3(*vertexpos[0]);
7194 vertex[1] = new TVector3(*vertexpos[1]);
7195 vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
7196 vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
7197 vertex[4] = new TVector3(*vertexpos[2]);
7198 vertex[5] = new TVector3(*vertexpos[3]);
7199 vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
7200 vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
7201 /////////////////////////////////////////////////////////////
7202 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
7203 for(Int_t i = 0; i<kvertexnumber;i++)
7204 arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
bf210566 7205 /////////////////////////////////////////////////////////////
7206 // Deallocating memory
7207 /////////////////////////////////////////////////////////////
7208 for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
7209 for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
7210 /////////////////////////////////////////////////////////////
44285dfa 7211 return arbshape;
d7599219 7212}
bf210566 7213///////////////////////////////////////////////////////////////////////////////
7214TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
7215 Double_t rmax, Int_t nedges, Double_t height){
7216 /////////////////////////////////////////////////////////////
7217 // Method generating Arc shape
7218 /////////////////////////////////////////////////////////////
7219 const Int_t kvertexnumber = 2*nedges+2;
7220 TGeoXtru* arcshape = new TGeoXtru(2);
7221 TVector3** vertexposition[2];
7222 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
7223 Double_t angle = 0.;
7224 for(Int_t i=0; i<nedges+1; i++){
7225 angle = 90.+0.5*phi-i*(phi/nedges);
7226 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
7227 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
7228 }
7229 Double_t *xvertexpoints = new Double_t[kvertexnumber];
7230 Double_t *yvertexpoints = new Double_t[kvertexnumber];
7231 for(Int_t i=0; i<kvertexnumber; i++){
7232 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
7233 yvertexpoints[i] = vertexposition[0][i]->Y();
7234 }
7235 else if(i>=1&&i<nedges+2)
7236 {
7237 xvertexpoints[i] = vertexposition[1][i-1]->X();
7238 yvertexpoints[i] = vertexposition[1][i-1]->Y();
7239 }
7240 else
7241 {
7242 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
7243 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
7244 }
7245 }
7246 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
7247 arcshape->DefineSection(0,-0.5*height);
7248 arcshape->DefineSection(1,0.5*height);
44285dfa 7249 /////////////////////////////////////////////////////////////
bf210566 7250 // Deallocating memory
44285dfa 7251 /////////////////////////////////////////////////////////////
bf210566 7252 for(Int_t i=0; i<2; i++){
7253 for(Int_t j=0; j<nedges+1; j++)
7254 delete vertexposition[i][j];
7255 delete [] vertexposition[i];
7256 }
7257 delete [] xvertexpoints;
7258 delete [] yvertexpoints;
7259 /////////////////////////////////////////////////////////////
7260 return arcshape;
d7599219 7261}
7262////////////////////////////////////////////////////////////////////////////////
9b0c60ab 7263TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
7264 ///////////////////////////////////////////////////////////////////////
7265 // Method Generating the Screw Shape
7266 // radius[0]: outer radius
7267 // radius[1]: inner radius
7268 // edgesnumber[0]: outer number of edges
7269 // edgesnumber[1]: inner number of edges
7270 // section[0]: lower section position
7271 // section[1]: higher section position
7272 ///////////////////////////////////////////////////////////////////////
7273 Double_t outradius = radius[0];
7274 Double_t inradius = radius[1];
7275 Int_t outvertexnumber = edgesnumber[0];
7276 Int_t invertexnumber = edgesnumber[1];
7277 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7278 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7279 for(Int_t i=0; i<outvertexnumber+1; i++){
7280 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
7281 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
7282 }
7283 for(Int_t i=0; i<invertexnumber+1; i++){
7284 xscrewvertex[outvertexnumber+i+1] = inradius*CosD(90.-i*360./invertexnumber);
7285 yscrewvertex[outvertexnumber+i+1] = inradius*SinD(90.-i*360./invertexnumber);
7286 }
7287 TGeoXtru* screwshape = new TGeoXtru(2);
7288 screwshape->DefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex);
7289 screwshape->DefineSection(0,section[0]);
7290 screwshape->DefineSection(1,section[1]);
7291 delete [] xscrewvertex;
7292 delete [] yscrewvertex;
7293 return screwshape;
7294}
7295////////////////////////////////////////////////////////////////////////////////
7296TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
7297 ///////////////////////////////////////////////////////////////////////
7298 // Method Generating the Hole Shape
7299 // radius of the Hole
7300 // nedges: number of edges to approximate the circle
7301 ///////////////////////////////////////////////////////////////////////
7302 Int_t vertexnumber = nedges+6;
7303 Double_t* xholevertex = new Double_t[vertexnumber];
7304 Double_t* yholevertex = new Double_t[vertexnumber];
7305 xholevertex[0] = radius;
7306 xholevertex[1] = xholevertex[0];
7307 xholevertex[2] = -xholevertex[1];
7308 xholevertex[3] = xholevertex[2];
7309 xholevertex[4] = xholevertex[0];
7310 yholevertex[0] = 0.;
7311 yholevertex[1] = -radius;
7312 yholevertex[2] = yholevertex[1];
7313 yholevertex[3] = -yholevertex[1];
7314 yholevertex[4] = yholevertex[3];
7315 for(Int_t i=0; i<nedges+1; i++){
7316 xholevertex[i+5] = radius*CosD(i*360./nedges);
7317 yholevertex[i+5] = radius*SinD(i*360./nedges);
7318 }
7319 TGeoXtru* holeshape = new TGeoXtru(2);
7320 holeshape->DefinePolygon(vertexnumber,xholevertex,yholevertex);
7321 holeshape->DefineSection(0,section[0]);
7322 holeshape->DefineSection(1,section[1]);
7323 delete [] xholevertex;
7324 delete [] yholevertex;
7325 return holeshape;
7326}
7327////////////////////////////////////////////////////////////////////////////////
44285dfa 7328TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
7329 /////////////////////////////////////////////////////////////
7330 // Given an axis specified by param, it gives the reflection of the point
7331 // respect to the axis
7332 /////////////////////////////////////////////////////////////
7333 TVector3* n = new TVector3(param[0],param[1],param[2]);
7334 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
7335 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 7336 /////////////////////////////////////////////////////////////
7337 // Deallocating memory
7338 /////////////////////////////////////////////////////////////
7339 delete n;
7340 /////////////////////////////////////////////////////////////
44285dfa 7341 return reflectedvector;
d7599219 7342}
7343////////////////////////////////////////////////////////////////////////////////
bf210566 7344TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
d7599219 7345 Double_t dx,
7346 Double_t dy,
7347 Double_t dz) const{
44285dfa 7348 /////////////////////////////////////////////////////////////
d7599219 7349 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 7350 /////////////////////////////////////////////////////////////
bf210566 7351 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
7352 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 7353 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 7354 hmatrix->SetTranslation(newvect);
7355 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
7356 delete hmatrix;
7357 return matrix;
d7599219 7358}
7359////////////////////////////////////////////////////////////////////////////////
d7599219 7360TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 7361 /////////////////////////////////////////////////////////////
7362 // Method returning the Medium type
7363 /////////////////////////////////////////////////////////////
d7599219 7364 char ch[30];
7365 sprintf(ch, "ITS_%s",mediumName);
7366 TGeoMedium* medium = gGeoManager->GetMedium(ch);
7367 if (! medium)
7368 printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
7369 return medium;
7370}
7371////////////////////////////////////////////////////////////////////////////////
d7599219 7372void AliITSv11GeometrySSD::CreateMaterials(){
7373///////////////////////////////////
7374// This part has to be modified
7375///////////////////////////////////
7376 ///////////////////////////////////
7377 // Silicon for Sensor
7378 ///////////////////////////////////
bf210566 7379 fSSDSensorMedium = GetMedium("SI$");
d7599219 7380 ///////////////////////////////////
7381 // Silicon Mixture for Sensor
7382 ///////////////////////////////////
44285dfa 7383 fSSDChipMedium = GetMedium("SPD SI CHIP$");
7384 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 7385 ///////////////////////////////////
7386 // Stiffener Components Materials
7387 ///////////////////////////////////
bf210566 7388 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 7389 ///////////////////////////
7390 // Stiffener Connectors
7391 ///////////////////////////
bf210566 7392 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 7393 ////////////////////////////////
7394 // Stiffener 0603-1812 Capacitor
7395 ////////////////////////////////
bf210566 7396 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
7397 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
d7599219 7398 ///////////////////////////
7399 // Stiffener Hybrid Wire
7400 ///////////////////////////
bf210566 7401 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 7402 ///////////////////////////
7403 // Al for Cooling Block
7404 ///////////////////////////
bf210566 7405 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 7406 //////////////////////////////////////////////////////
7407 // Kapton and Al for Chip Cable Flex and Ladder Cables
7408 //////////////////////////////////////////////////////
bf210566 7409 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7410 fSSDAlTraceChipCableMedium = GetMedium("AL$");
7411 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
7412 fSSDAlTraceFlexMedium = GetMedium("AL$");
7413 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7414 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 7415 /////////////////////////////////////////////////////////////////
7416 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
7417 //////////////////////////////////////////////////////////////////
44285dfa 7418 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 7419 /////////////////////////////////////////////////////////////////
7420 // G10 for Detector Leg, TubeHolder
7421 //////////////////////////////////////////////////////////////////
44285dfa 7422 fSSDTubeHolderMedium = GetMedium("G10FR4$");
7423 fSSDSensorSupportMedium = GetMedium("G10FR4$");
7424 fSSDMountingBlockMedium = GetMedium("G10FR4$");
7425 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 7426 /////////////////////////////////////////////////////////////////
7427 // Water and Phynox for Cooling Tube
7428 //////////////////////////////////////////////////////////////////
bf210566 7429 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 7430 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 7431 /////////////////////////////////////////////////////////////////////
9b0c60ab 7432 // Material for Support Rings
7433 /////////////////////////////////////////////////////////////////////
7434 fSSDSupportRingAl = GetMedium("AL$");
7435 /////////////////////////////////////////////////////////////////////
bf210566 7436 fSSDAir = GetMedium("SDD AIR$");
7437 fCreateMaterials = kTRUE;
d7599219 7438}
7439/////////////////////////////////////////////////////////////////////