]> 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
Bug fix: enlarged array size, corrected initialization (linuxia64gcc)
[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
5ef8864c 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"
851c0ce3 32#include "TGeoBoolNode.h"
d7599219 33#include "TGeoTube.h"
34#include "TGeoBBox.h"
bf210566 35#include "TGeoXtru.h"
9b0c60ab 36#include "TGeoTorus.h"
37#include "TGeoPgon.h"
47f8de53 38#include "TGeoPcon.h"
9b0c60ab 39#include "TRotation.h"
44285dfa 40#include "AliITSv11GeometrySSD.h"
d7599219 41/////////////////////////////////////////////////////////////////////////////////
bf210566 42// Names of the Sensitive Volumes of Layer 5 and Layer 6
43/////////////////////////////////////////////////////////////////////////////////
02d4acf9 44const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5";
45const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6";
bf210566 46/////////////////////////////////////////////////////////////////////////////////
d7599219 47//Parameters for SSD Geometry
48/////////////////////////////////////////////////////////////////////////////////
e21cdd03 49// Variable for Vertical Disalignement of Modules
50/////////////////////////////////////////////////////////////////////////////////
ca86fdb4 51const Double_t AliITSv11GeometrySSD::fgkSSDTolerance = 0.0001*fgkmm;
0fb26117 52const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
53const Double_t AliITSv11GeometrySSD::fgkSSDModuleSideDisalignment = 0.2*fgkmm;
e21cdd03 54/////////////////////////////////////////////////////////////////////////////////
d7599219 55// Layer5 (lengths are in mm and angles in degrees)
56/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 57const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
d7599219 58const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
59const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
9acf2ecc 60const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
61const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
62const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
d7599219 63/////////////////////////////////////////////////////////////////////////////////
64// Layer6 (lengths are in mm and angles in degrees)
65/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 66const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
d7599219 67const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
68const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
9acf2ecc 69const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
70const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
71const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
d7599219 72/////////////////////////////////////////////////////////////////////////////////
73// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
74/////////////////////////////////////////////////////////////////////////////////
75const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
9acf2ecc 76const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
77const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
78const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
79const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
bf210566 80const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
81const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
9acf2ecc 82const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
d7599219 83/////////////////////////////////////////////////////////////////////////////////
84// Stiffener (lengths are in mm and angles in degrees)
85/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 86const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
87const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
bf210566 88//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 3.315;
9acf2ecc 89const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm;
90const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
bf210566 91const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
9acf2ecc 92const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
93const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
94const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
95const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
bf210566 96const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 0.700*fgkmm; // multiplied by 0.5
9acf2ecc 97const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
98const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
bf210566 99const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] =
100 {44.32*fgkmm, 0.33*fgkmm};
101const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
102const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
103const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
d7599219 104const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight =
bf210566 105 0.25*fgkSSDStiffenerHeight;
106const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
107const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
d7599219 108/////////////////////////////////////////////////////////////////////////////////
109// Cooling Block (lengths are in mm and angles in degrees)
110/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 111const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
112const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
bf210566 113const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
114 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
d7599219 115const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
bf210566 116 {1.000*fgkmm, 0.120*fgkmm};
d7599219 117const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
bf210566 118 {1.900*fgkmm, 0.400*fgkmm};
d7599219 119const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
9acf2ecc 120 1.500*fgkmm;
d7599219 121const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
9acf2ecc 122 0.300*fgkmm;
d7599219 123/////////////////////////////////////////////////////////////////////////////////
124// SSD Sensor (lengths are in mm and angles in degrees)
125/////////////////////////////////////////////////////////////////////////////////
126const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
bf210566 127 "SSDSensorSensitiveVol";
9acf2ecc 128const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
129const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
130const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
d7599219 131const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
9acf2ecc 132 fgkSSDSensorLength-39.1*fgkmm;
bf210566 133const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
134const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
d7599219 135/////////////////////////////////////////////////////////////////////////////////
136// Flex (lengths are in mm and angles in degrees)
137/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 138const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
d7599219 139const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
bf210566 140 {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
141 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
142 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
143 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
144 - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
d7599219 145const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
bf210566 146 { 9.340*fgkmm, 5.380*fgkmm};
d7599219 147const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
bf210566 148 { 0.030*fgkmm, 0.020*fgkmm};
d7599219 149const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
9acf2ecc 150const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
151const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
d7599219 152const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
bf210566 153 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
d7599219 154const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
bf210566 155 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
d7599219 156/////////////////////////////////////////////////////////////////////////////////
157// SSD Ladder Cable (lengths are in mm and angles in degrees)
158/////////////////////////////////////////////////////////////////////////////////
bf210566 159const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
d7599219 160/////////////////////////////////////////////////////////////////////////////////
161// SSD Module (lengths are in mm and angles in degrees)
162/////////////////////////////////////////////////////////////////////////////////
163const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
bf210566 164 { 1.000*fgkmm, 3.900*fgkmm};
d7599219 165const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
9acf2ecc 166 45.600*fgkmm;
d7599219 167const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
9acf2ecc 168 5.075*fgkmm;
d7599219 169/////////////////////////////////////////////////////////////////////////////////
170// Sensor Support (lengths are in mm and angles in degrees)
171/////////////////////////////////////////////////////////////////////////////////
bf210566 172const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
173 5.800*fgkmm;
d7599219 174const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
bf210566 175 2.000*fgkmm;
d7599219 176const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
0fb26117 177 { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment,
178 5.220*fgkmm-fgkSSDModuleVerticalDisalignment};
ca86fdb4 179//const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
180// { 4.520*fgkmm, 5.130*fgkmm};
bf210566 181const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
182 { 0.450*fgkmm, 0.450*fgkmm};
183const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
184 = 0.5 * (fgkSSDModuleSensorSupportDistance
185 + fgkSSDSensorSideSupportThickness[0])
186 - fgkSSDSensorSideSupportLength;
d7599219 187const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
bf210566 188 5.250*fgkmm;
d7599219 189const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
bf210566 190 1.680*fgkmm;
191const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
192 = {fgkSSDSensorSideSupportHeight[0]
193 + fgkSSDSensorSideSupportThickness[0],
194 fgkSSDSensorSideSupportHeight[1]
195 + fgkSSDSensorSideSupportThickness[1]};
196const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
197 = {fgkSSDSensorSideSupportThickness[0],
198 fgkSSDSensorSideSupportThickness[1]};
d7599219 199const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
bf210566 200 19.000*fgkmm;
d7599219 201/////////////////////////////////////////////////////////////////////////////////
202// Chip Cables (lengths are in mm and angles in degrees)
203/////////////////////////////////////////////////////////////////////////////////
204const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
bf210566 205 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
d7599219 206const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
bf210566 207 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
208 - (fgkSSDSensorSideSupportHeight[1]
209 - fgkSSDSensorSideSupportHeight[0])
0fb26117 210 - fgkSSDModuleVerticalDisalignment
bf210566 211 - fgkSSDCoolingBlockHoleCenter
212 - fgkSSDStiffenerHeight
213 - fgkSSDChipHeight-fgkSSDSensorHeight,
214 fgkSSDModuleCoolingBlockToSensor
0fb26117 215 - fgkSSDModuleVerticalDisalignment
bf210566 216 - fgkSSDCoolingBlockHoleCenter
217 - fgkSSDStiffenerHeight
218 - fgkSSDChipHeight-fgkSSDSensorHeight};
d7599219 219const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
bf210566 220 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
d7599219 221/////////////////////////////////////////////////////////////////////////////////
222// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
223/////////////////////////////////////////////////////////////////////////////////
224const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
bf210566 225 3.820*fgkmm;
226//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
227// 3.780;
d7599219 228const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
bf210566 229 fgkSSDSensorLength-fgkSSDSensorOverlap;
d7599219 230const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
bf210566 231 { 0.86*fgkmm, 0.30*fgkmm};
d7599219 232const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
bf210566 233 { 30.00, 90.00};
d7599219 234const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
bf210566 235 1.78*fgkmm;
d7599219 236/////////////////////////////////////////////////////////////////////////////////
237//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
238/////////////////////////////////////////////////////////////////////////////////
bf210566 239const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
240 = fgkSSDModuleSensorSupportDistance
241 - 2. * fgkCarbonFiberJunctionToSensorSupport;
242const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
d7599219 243const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
bf210566 244 { 0.751*fgkmm, 0.482*fgkmm};
245const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
246 1.630*fgkmm;
247const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
248const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
249 = fgkCarbonFiberTriangleLength
250 - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
251 / TMath::Cos(fgkCarbonFiberTriangleAngle
252 * TMath::DegToRad());
253const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
254 = 0.5*(fgkCarbonFiberJunctionWidth
255 - fgkCarbonFiberSupportWidth)
256 - fgkCarbonFiberSupportTopEdgeDist[0]
257 - fgkCarbonFiberSupportWidth;
d7599219 258/////////////////////////////////////////////////////////////////////////////////
259// Carbon Fiber Lower Support Parameters (lengths are in mm)
260/////////////////////////////////////////////////////////////////////////////////
c40ebacc 261const Double_t AliITSv11GeometrySSD::fgkLowerSupportToSensorZ = 11.575*fgkmm;
d7599219 262const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
9acf2ecc 263 = 0.950*fgkmm;
d7599219 264const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
9acf2ecc 265 = 1.600*fgkmm;
d7599219 266const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
9acf2ecc 267 = 0.830*fgkmm;
d7599219 268const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
269 = 0.5*fgkCarbonFiberSupportWidth;
270const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
bf210566 271 = fgkCarbonFiberJunctionWidth
272 - 2. * (fgkCarbonFiberLowerSupportWidth
273 + fgkCarbonFiberLowerSupportVolumeSeparation);
d7599219 274const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
bf210566 275 = {fgkCarbonFiberLowerSupportWidth
276 + fgkCarbonFiberLowerSupportVolumeSeparation,
277 fgkCarbonFiberLowerSupportWidth
278 + fgkCarbonFiberLowerSupportVolumeSeparation
279 + fgkCarbonFiberLowerSupportTransverseWidth};
d7599219 280/////////////////////////////////////////////////////////////////////////////////
281// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
282/////////////////////////////////////////////////////////////////////////////////
283const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
bf210566 284 {0.5 * (fgkSSDLay5LadderLength
285 - fgkSSDLay5SensorsNumber
286 * fgkCarbonFiberJunctionWidth
287 - fgkCarbonFiberLowerSupportWidth),
288 0.5 * (fgkSSDLay5LadderLength
289 - fgkSSDLay5SensorsNumber
290 * fgkCarbonFiberJunctionWidth
291 + fgkCarbonFiberLowerSupportWidth)};
d7599219 292const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
bf210566 293 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
294 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
d7599219 295const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
bf210566 296 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
297 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
9b0c60ab 298const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
299 {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
d7599219 300/////////////////////////////////////////////////////////////////////////////////
301// Cooling Tube Support (lengths are in mm and angles in degrees)
302/////////////////////////////////////////////////////////////////////////////////
bf210566 303const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
d7599219 304const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
305 = fgkSSDCoolingBlockHoleRadius[0];
bf210566 306const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
307const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
308const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
d7599219 309const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
bf210566 310 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
311const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
312 11.70*fgkmm;
d7599219 313/////////////////////////////////////////////////////////////////////////////////
314// Cooling Tube (lengths are in mm and angles in degrees)
315/////////////////////////////////////////////////////////////////////////////////
bf210566 316const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
317const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm;
318const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
d7599219 319 fgkCarbonFiberJunctionWidth;
320const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
bf210566 321 fgkSSDModuleSensorSupportDistance
322 + fgkSSDCoolingBlockLength;
9b0c60ab 323const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
d7599219 324/////////////////////////////////////////////////////////////////////////////////
325// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
326/////////////////////////////////////////////////////////////////////////////////
327const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
bf210566 328 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
d7599219 329const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
bf210566 330 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
d7599219 331const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
bf210566 332 20.0*fgkmm;
d7599219 333const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
bf210566 334 40.0;
d7599219 335const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
336 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
337const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
bf210566 338 2.5*fgkmm;
d7599219 339const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
bf210566 340 { 56.0*fgkmm, 12.0*fgkmm};
d7599219 341const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
bf210566 342 { 5.0*fgkmm, 2.9*fgkmm};
d7599219 343const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
bf210566 344 1.0*fgkmm;
d7599219 345const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
bf210566 346 6.0*fgkmm;
d7599219 347const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth =
bf210566 348 4.0*fgkmm;
d7599219 349const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
bf210566 350 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
d7599219 351/////////////////////////////////////////////////////////////////////////////////
9b0c60ab 352// SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
353/////////////////////////////////////////////////////////////////////////////////
354const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
355const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
356const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
357const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
358const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
359/////////////////////////////////////////////////////////////////////////////////
360// SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
361/////////////////////////////////////////////////////////////////////////////////
362const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
363const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
364const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
365 - fgkSSDMountingBlockHeight[1]
366 + 0.5*fgkCoolingTubeSupportHeight
367 + fgkSSDModuleCoolingBlockToSensor
368 - fgkMountingBlockSupportDownHeight,
369 fgkSSDLay6RadiusMin
370 - fgkSSDMountingBlockHeight[1]
371 + 0.5*fgkCoolingTubeSupportHeight
372 + fgkSSDModuleCoolingBlockToSensor
373 - fgkMountingBlockSupportDownHeight};
374const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
375 - fgkSSDMountingBlockHeight[1]
376 + 0.5*fgkCoolingTubeSupportHeight
377 + fgkSSDModuleCoolingBlockToSensor
378 - fgkMountingBlockSupportRadius[0],
379 fgkSSDLay6RadiusMax
380 - fgkSSDMountingBlockHeight[1]
381 + 0.5*fgkCoolingTubeSupportHeight
382 + fgkSSDModuleCoolingBlockToSensor
383 - fgkMountingBlockSupportRadius[1]};
384const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
385const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
386const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
387/////////////////////////////////////////////////////////////////////////////////
388// SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
389/////////////////////////////////////////////////////////////////////////////////
390const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
391const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
392const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
393const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
394 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
395const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
396 {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
397const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
398 {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
399const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
400const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
401const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
402const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
403const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
404const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
405/////////////////////////////////////////////////////////////////////////////////
406// SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
407/////////////////////////////////////////////////////////////////////////////////
408const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
409const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
410const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
411/////////////////////////////////////////////////////////////////////////////////
412// SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
413/////////////////////////////////////////////////////////////////////////////////
414const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
415 {10.5*fgkmm,9.25*fgkmm};
416const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
417const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
418const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
419 {182.3,177.9,84.4,70.0,35.0};
420const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
421 {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
422const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
423/////////////////////////////////////////////////////////////////////////////////
424// SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
425/////////////////////////////////////////////////////////////////////////////////
426const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
427 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
428const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
429 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
430 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
431const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
432/////////////////////////////////////////////////////////////////////////////////
433// SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
434/////////////////////////////////////////////////////////////////////////////////
435const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
436 {62.0*fgkmm,21.87*fgkmm};
437const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
7708d5f3 438 {47.0*fgkmm,0.35*fgkmm};
9b0c60ab 439const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
440 1.0*fgkmm;
441const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
442const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
443 {43.5*fgkmm, 0.70*fgkmm};
444const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
445 0.15*fgkmm;
446const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
447 19.0*fgkmm;
448const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
449 {4.80*fgkmm,1.1*fgkmm};
450const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
451 {3.3*fgkmm,1.10*fgkmm};
452const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
453 2.1*fgkmm;
454const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
455 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
456const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
457 {1.9*fgkmm,0.15*fgkmm};
458const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
459 19*fgkmm;
460const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
461 1.0*fgkmm;
462const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
463 3.6*fgkmm;
464const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
465 61.0*fgkmm;
466const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
467 5.97*fgkmm;
468const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
469const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
470 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
471 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
472const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
473 {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
474const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
475 1.0*fgkmm;
476const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
477 = 0.15*fgkmm;
478const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
479 20.0*fgkmm;
480const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
481const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
482const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
483const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
484const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
485/////////////////////////////////////////////////////////////////////////////////
486// SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
487/////////////////////////////////////////////////////////////////////////////////
488const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
489const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
47f8de53 490const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {375.0*fgkmm,435.0*fgkmm};
9b0c60ab 491const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
492const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
493const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
494const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
495const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
496const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
497/////////////////////////////////////////////////////////////////////////////////
47f8de53 498// SSD Cone Parameters (lengths are in mm and angles in degrees)
499/////////////////////////////////////////////////////////////////////////////////
500const Double_t AliITSv11GeometrySSD::fgkSSDLowerPConeRadius = 296.5*fgkmm;
501const Double_t AliITSv11GeometrySSD::fgkSSDPConeAngle = 39.0;
fcfbdd23 502const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {168.0*fgkmm,153.0*fgkmm};
47f8de53 503const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleRadius = 317.5*fgkmm;
504const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleLength = 20.*fgkmm;
505const Double_t AliITSv11GeometrySSD::fgkSSDConeMiddleRadius = 350.*fgkmm;
506const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleLength = 30.*fgkmm;
507const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleWidth = 40.*fgkmm;
508const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpRadius = 400.*fgkmm;
fcfbdd23 509const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 459.*fgkmm;
47f8de53 510const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMiddleRadius = 472.5*fgkmm;
511const Double_t AliITSv11GeometrySSD::fgkSSDPConeDownRadius = 282.0*fgkmm;
512const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidAngle = 42.0;
513const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidBasis = 200.0*fgkmm;
514const Double_t AliITSv11GeometrySSD::fgkSSDPConeExternalRadius = 492.5*fgkmm;
515const Double_t AliITSv11GeometrySSD::fgkSSDPConeRadiusWidth = 16.75*fgkmm;
fcfbdd23 516const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 168.0*fgkmm;
47f8de53 517const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportLength = 1020.*fgkmm;
518const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm;
519const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm;
520const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportLength = 60.0*fgkmm;
521const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportWidth = 2.5*fgkSSDCentralSupportWidth;
522/////////////////////////////////////////////////////////////////////////////////
523// SSD Cables Parameters (lengths are in mm and angles in degrees)
524/////////////////////////////////////////////////////////////////////////////////
525const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
526const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
527const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
528const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
529const Double_t AliITSv11GeometrySSD::fgkSSDCableAngle = 22.5;
530const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm; // to be fixed in order to reproduce material budget
531const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
532const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
533const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
534const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
535const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = 451.3*fgkmm;
536const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = 451.3*fgkmm;
537const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeigth = 87.5*fgkmm;
538const Double_t AliITSv11GeometrySSD::fgkSSDCableMaterialBudgetHeight = 20.0*fgkmm;
539//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = fgkSSDPConeExternalRadius;
540//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = fgkSSDPConeExternalRadius;
541/////////////////////////////////////////////////////////////////////////////////
44285dfa 542ClassImp(AliITSv11GeometrySSD)
543/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 544AliITSv11GeometrySSD::AliITSv11GeometrySSD():
545 AliITSv11Geometry(),
44285dfa 546 fSSDChipMedium(),
547 fSSDChipGlueMedium(),
548 fSSDStiffenerMedium(),
549 fSSDStiffenerConnectorMedium(),
550 fSSDStiffener0603CapacitorMedium(),
551 fSSDStiffener1812CapacitorMedium(),
552 fSSDStiffenerHybridWireMedium(),
553 fSSDKaptonFlexMedium(),
554 fSSDAlTraceFlexMedium(),
555 fSSDAlTraceLadderCableMedium(),
556 fSSDKaptonLadderCableMedium(),
557 fSSDKaptonChipCableMedium(),
558 fSSDAlTraceChipCableMedium(),
559 fSSDAlCoolBlockMedium(),
560 fSSDSensorMedium(),
561 fSSDSensorSupportMedium(),
562 fSSDCarbonFiberMedium(),
563 fSSDTubeHolderMedium(),
564 fSSDCoolingTubeWater(),
565 fSSDCoolingTubePhynox(),
9b0c60ab 566 fSSDSupportRingAl(),
44285dfa 567 fSSDMountingBlockMedium(),
47f8de53 568 fSSDRohaCellCone(),
bf210566 569 fSSDAir(),
47f8de53 570 fSSDCopper(),
bf210566 571 fCreateMaterials(kFALSE),
572 fTransformationMatrices(kFALSE),
573 fBasicObjects(kFALSE),
574 fcarbonfiberjunction(),
575 fcoolingtubesupport(),
576 fhybridmatrix(),
577 fssdcoolingblocksystem(),
578 fcoolingblocksystematrix(),
579 fssdstiffenerflex(),
580 fssdendflex(),
9b0c60ab 581 fendladdercoolingtubesupportmatrix(),
bf210566 582 fendladdermountingblock(),
9b0c60ab 583 fendladdermountingblockclip(),
bf210566 584 fSSDSensor5(),
585 fSSDSensor6(),
586 fSSDLayer5(),
587 fSSDLayer6(),
588 fMotherVol(),
9b0c60ab 589 fLay5LadderSupportRing(),
590 fLay6LadderSupportRing(),
e5bf64ae 591 fgkEndCapSupportSystem(),
47f8de53 592 fSSDCone(),
44285dfa 593 fColorCarbonFiber(4),
594 fColorRyton(5),
bf210566 595 fColorPhynox(14),
44285dfa 596 fColorSilicon(3),
bf210566 597 fColorAl(38),
44285dfa 598 fColorKapton(6),
599 fColorPolyhamide(5),
600 fColorStiffener(9),
bf210566 601 fColorEpoxy(30),
602 fColorWater(7),
603 fColorG10(41)
44285dfa 604{
605 ////////////////////////
606 // Standard constructor
607 ////////////////////////
44285dfa 608}
609/////////////////////////////////////////////////////////////////////////////////
610AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
9acf2ecc 611 AliITSv11Geometry(s.GetDebug()),
44285dfa 612 fSSDChipMedium(s.fSSDChipMedium),
613 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
614 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
615 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
616 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
617 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
618 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
619 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
620 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
621 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
622 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
623 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
624 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
625 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
626 fSSDSensorMedium(s.fSSDSensorMedium),
627 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
628 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
629 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
630 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
631 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
9b0c60ab 632 fSSDSupportRingAl(s.fSSDSupportRingAl),
44285dfa 633 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
47f8de53 634 fSSDRohaCellCone(s.fSSDRohaCellCone),
bf210566 635 fSSDAir(s.fSSDAir),
47f8de53 636 fSSDCopper(s.fSSDCopper),
bf210566 637 fCreateMaterials(s.fCreateMaterials),
638 fTransformationMatrices(s.fTransformationMatrices),
639 fBasicObjects(s.fBasicObjects),
640 fcarbonfiberjunction(s.fcarbonfiberjunction),
641 fcoolingtubesupport(s.fcoolingtubesupport),
642 fhybridmatrix(s.fhybridmatrix),
643 fssdcoolingblocksystem(s.fssdcoolingblocksystem),
644 fcoolingblocksystematrix(s.fcoolingblocksystematrix),
645 fssdstiffenerflex(s.fssdstiffenerflex),
646 fssdendflex(s.fssdendflex),
9b0c60ab 647 fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
bf210566 648 fendladdermountingblock(s.fendladdermountingblock),
9b0c60ab 649 fendladdermountingblockclip(s.fendladdermountingblockclip),
bf210566 650 fSSDSensor5(s.fSSDSensor5),
651 fSSDSensor6(s.fSSDSensor6),
652 fSSDLayer5(s.fSSDLayer5),
653 fSSDLayer6(s.fSSDLayer6),
44285dfa 654 fMotherVol(s.fMotherVol),
9b0c60ab 655 fLay5LadderSupportRing(s.fLay5LadderSupportRing),
656 fLay6LadderSupportRing(s.fLay6LadderSupportRing),
e5bf64ae 657 fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
47f8de53 658 fSSDCone(s.fSSDCone),
44285dfa 659 fColorCarbonFiber(s.fColorCarbonFiber),
660 fColorRyton(s.fColorRyton),
661 fColorPhynox(s.fColorPhynox),
662 fColorSilicon(s.fColorSilicon),
663 fColorAl(s.fColorAl),
664 fColorKapton(s.fColorKapton),
665 fColorPolyhamide(s.fColorPolyhamide),
666 fColorStiffener(s.fColorStiffener),
bf210566 667 fColorEpoxy(s.fColorEpoxy),
668 fColorWater(s.fColorWater),
669 fColorG10(s.fColorG10)
44285dfa 670{
671 ////////////////////////
672 // Copy Constructor
673 ////////////////////////
d7599219 674}
675/////////////////////////////////////////////////////////////////////////////////
44285dfa 676AliITSv11GeometrySSD& AliITSv11GeometrySSD::
677operator=(const AliITSv11GeometrySSD &s){
678 ////////////////////////
679 // Assignment operator
680 ////////////////////////
681 this->~AliITSv11GeometrySSD();
682 new(this) AliITSv11GeometrySSD(s);
683 return *this;
684/*
685 if(&s == this) return *this;
686 fMotherVol = s.fMotherVol;
687 return *this;
688 */
689}
bf210566 690///////////////////////////////////////////////////////////////////////////////
691void AliITSv11GeometrySSD::CreateTransformationMatrices(){
692 ///////////////////////////////////////////////////////////////////////
693 // Method generating the trasformation matrix for the whole SSD Geometry
694 ///////////////////////////////////////////////////////////////////////
695 // Setting some variables for Carbon Fiber Supportmatrix creation
696 //////////////////////////////////////////////////////////////////////
697 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
698 * CosD(fgkCarbonFiberJunctionAngle[0]);
699 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
700 + fgkCarbonFiberSupportTopEdgeDist[0]
701 + fgkCarbonFiberSupportWidth);
702 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
703 * TanD(fgkCarbonFiberJunctionAngle[0]);
704 TGeoRotation* carbonfiberot[3];
705 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
706 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
707 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
708 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
709 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
710 * CosD(fgkCarbonFiberTriangleAngle),0.,
711 - fgkCarbonFiberTriangleLength
712 * SinD(fgkCarbonFiberTriangleAngle)};
713 ///////////////////////////////////////////
714 //Setting Local Translations and Rotations:
715 ///////////////////////////////////////////
716 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
717 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
718 0.5*carbonfibersupportheight,NULL);
719 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
720 2.*symmetryplaneposition+transvector[1],
721 transvector[2], carbonfiberot[2]);
722 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
723 /////////////////////////////////////////////////////////////
724 // Carbon Fiber Support Transformations
725 /////////////////////////////////////////////////////////////
726 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
727 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
728 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
729 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
730 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
731 }
732 /////////////////////////////////////////////////////////////
733 // Carbon Fiber Junction Transformation
734 /////////////////////////////////////////////////////////////
735 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
736 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
737 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
738 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
739 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
740 localcarbonfiberjunctionmatrix[i] =
741 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
742 localcarbonfiberjunctionrot[i] =
743 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
744 localcarbonfiberjunctiontrans[i] =
745 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 746 }
bf210566 747 ///////////////////////
748 // Setting Translations
749 ///////////////////////
750 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
751 localcarbonfiberjunctiontrans[1][0] =
752 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
753 localcarbonfiberjunctiontrans[2][0] =
754 new TGeoTranslation(fgkCarbonFiberTriangleLength
755 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
756 fgkCarbonFiberTriangleLength
757 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
758 localcarbonfiberjunctiontrans[0][1] =
759 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
760 localcarbonfiberjunctiontrans[1][1] =
761 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
762 localcarbonfiberjunctiontrans[2][1] =
763 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
764 ////////////////////
765 // Setting Rotations
766 ////////////////////
767 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
768 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
769 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
770 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
771 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
772 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
773 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
774 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
775 ////////////////////////////////////////
776 // Setting Carbon Fiber Junction matrix
777 ////////////////////////////////////////
778 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
779 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
780 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
781 localcarbonfiberjunctionmatrix[i][j] =
782 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
783 *localcarbonfiberjunctionrot[i][j]);
784 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
785 }
d7599219 786 }
bf210566 787 /////////////////////////////////////////////////////////////
788 // Carbon Fiber Lower Support Transformations
789 /////////////////////////////////////////////////////////////
790 TGeoTranslation* localcarbonfiberlowersupportrans[2];
791 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
792 fgkCarbonFiberLowerSupportVolumePosition[1]
793 + fgkCarbonFiberLowerSupportVolumePosition[0],
794 0.0);
795 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
796 fgkCarbonFiberJunctionWidth
797 - fgkCarbonFiberLowerSupportWidth
798 - fgkCarbonFiberLowerSupportVolumePosition[0]
799 - fgkCarbonFiberLowerSupportVolumePosition[1],
800 - 0.5*fgkCarbonFiberLowerSupportHeight);
801 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
802 fcarbonfiberlowersupportrans[0] =
803 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
804 fcarbonfiberlowersupportrans[1] =
805 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
806 /////////////////////////////////////////////////////////////
807 // SSD Sensor Support Transformations
808 /////////////////////////////////////////////////////////////
809 const Int_t kssdsensorsupportmatrixnumber = 3;
810 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
811 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
812 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
813 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
814 localssdsensorsupportmatrix[i] =
815 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
816 localssdsensorsupportrot[i] =
817 new TGeoRotation*[kssdsensorsupportmatrixnumber];
818 localssdsensorsupportrans[i] =
819 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 820 }
bf210566 821 ///////////////////////
822 // Setting Translations
823 ///////////////////////
824 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
825 0.5*fgkSSDSensorSideSupportWidth,
826 0.0);
827 localssdsensorsupportrans[1][0] =
828 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
829 localssdsensorsupportrans[2][0] =
830 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
831 localssdsensorsupportrans[0][1] =
832 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
833 0.5*fgkSSDSensorSideSupportThickness[0],
834 0.0);
835 localssdsensorsupportrans[1][1] =
836 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
837 - 0.5*fgkSSDSensorSideSupportThickness[0]
838 - fgkSSDModuleSensorSupportDistance,
839 0.0);
840 localssdsensorsupportrans[2][1] =
841 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
842 - fgkSSDSensorCenterSupportPosition,
843 0.5*fgkSSDSensorCenterSupportWidth
844 - 0.5*fgkSSDModuleSensorSupportDistance,
845 fgkSSDSensorCenterSupportThickness[0]);
846 localssdsensorsupportrans[0][2] =
847 new TGeoTranslation(fgkCarbonFiberTriangleLength
848 + fgkCarbonFiberJunctionToSensorSupport,
849 fgkCarbonFiberJunctionWidth
850 - 0.5*(fgkCarbonFiberLowerSupportWidth
851 + fgkSSDSensorCenterSupportLength
852 - fgkSSDSensorCenterSupportThickness[0])
853 - fgkSSDSensorCenterSupportPosition,
854 0.0);
855 localssdsensorsupportrans[1][2] =
856 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
857 localssdsensorsupportrans[2][2] =
858 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
859 ////////////////////
860 // Setting Rotations
861 ////////////////////
862 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
863 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
864 localssdsensorsupportrot[i][j] = new TGeoRotation();
865 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
866 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
867 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 868 }
bf210566 869 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
870 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
871 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
872 ////////////////////////////////////////
873 // SSD Sensor Support matrix
874 ////////////////////////////////////////
875 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
876 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
877 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
878 localssdsensorsupportmatrix[i][j] =
879 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
880 *localssdsensorsupportrot[i][j]);
881 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
882 }
d7599219 883 }
44285dfa 884 /////////////////////////////////////////////////////////////
bf210566 885 // SSD Cooling Tube Support Transformations
44285dfa 886 /////////////////////////////////////////////////////////////
bf210566 887 const Int_t kcoolingtubesupportmatrixnumber = 2;
888 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
889 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
890 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 891 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 892 /fgkCoolingTubeSupportRmax);
bf210566 893 localcoolingtubesupportrans[0] =
894 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 895 + 2.*(fgkCoolingTubeSupportLength
44285dfa 896 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 897 + fgkCarbonFiberTriangleLength
bf210566 898 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
899 localcoolingtubesupportrans[1] =
900 new TGeoTranslation(fgkCarbonFiberJunctionLength
901 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
902 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
903 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
904 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
905 - 0.5*(fgkCarbonFiberLowerSupportWidth
906 + fgkSSDSensorCenterSupportLength
907 - fgkSSDSensorCenterSupportThickness[0])
908 + 0.5*fgkSSDSensorLength,
909 - 0.5*fgkCoolingTubeSupportHeight);
910 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
911 localcoolingtubesupportrot[i] = new TGeoRotation();
912 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
913 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
914 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
915 localcoolingtubesupportmatrix[i] =
916 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
917 *localcoolingtubesupportrot[i]);
918 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
919 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
920 (*localcoolingtubesupportmatrix[0]));
921 /////////////////////////////////////////////////////////////
9b0c60ab 922 // End Ladder SSD Cooling Tube Support Transformations
923 /////////////////////////////////////////////////////////////
924 TGeoTranslation** localendladdercooltubetrans[2];
925 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
926 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
927 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
928 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
929 - (fgkCoolingTubeSupportLength
930 - fgkCoolingTubeSupportRmax),
931 fgkEndLadderMountingBlockPosition[0]
932 - fgkendladdercoolingsupportdistance[0]
933 + 0.5*fgkCoolingTubeSupportWidth,
934 - 0.5*fgkCoolingTubeSupportHeight);
935 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
936 - (fgkCoolingTubeSupportLength
937 - fgkCoolingTubeSupportRmax),
938 fgkEndLadderMountingBlockPosition[0]
939 + fgkendladdercoolingsupportdistance[1]
940 + 0.5*fgkCoolingTubeSupportWidth,
941 - 0.5*fgkCoolingTubeSupportHeight);
942 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
943 - fgkCoolingTubeSupportRmax)
944 + fgkCarbonFiberTriangleLength
945 - 2.0*fgkCarbonFiberJunctionLength,
946 0.0,
947 0.0);
948 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
949 fgkendladdercoolingsupportdistance[0]
950 + fgkendladdercoolingsupportdistance[1],
951 0.0);
952 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
953 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
954 + fgkCarbonFiberJunctionLength
955 - fgkCoolingTubeSupportLength,
956 fgkEndLadderCarbonFiberLowerJunctionLength[1]
957 - 0.5*fgkCoolingTubeSupportWidth
958 -fgkendladdercoolingsupportdistance[2],
959 - 0.5*fgkCoolingTubeSupportHeight);
960 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
961 + fgkCoolingTubeSupportLength
962 - fgkCoolingTubeSupportRmax
963 - fgkCarbonFiberJunctionLength,
964 fgkEndLadderCarbonFiberLowerJunctionLength[1]
965 - 0.5*fgkCoolingTubeSupportWidth
966 - fgkendladdercoolingsupportdistance[2],
967 - 0.5*fgkCoolingTubeSupportHeight);
968 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
969 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
970 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
971 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
972 (*localcoolingtubesupportrot[1]));
973 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
974 (*localcoolingtubesupportrot[1]));
975 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
976 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
977 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
978 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
979 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
980
981 fendladdercoolingtubesupportmatrix[1][0] =
982 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
983 *(*localcoolingtubesupportrot[1]));
984 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
985 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
986 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
987 /////////////////////////////////////////////////////////////
bf210566 988 // SSD Cooling Tube Transformations
989 /////////////////////////////////////////////////////////////
990 TGeoRotation* localcoolingtuberot = new TGeoRotation();
991 localcoolingtuberot->SetAngles(0.,90.,0.);
992 TGeoTranslation** localcoolingtubetrans[4];
993 TVector3** localcoolingtubevect[4];
994 for(Int_t i=0; i<4; i++){
995 localcoolingtubevect[i] = new TVector3*[2];
996 localcoolingtubetrans[i] = new TGeoTranslation*[2];
997 fcoolingtubematrix[i] = new TGeoHMatrix*[2];
d7599219 998 }
bf210566 999 localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
1000 -fgkCarbonFiberTriangleLength),
1001 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1002 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1003 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1004 - 0.5*(fgkCarbonFiberLowerSupportWidth
1005 + fgkSSDSensorCenterSupportLength
1006 - fgkSSDSensorCenterSupportThickness[0])+
1007 0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
1008 - 2.0*fgkSSDModuleStiffenerPosition[1]
1009 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
1010 - 0.5*fgkCoolingTubeSupportWidth,
1011 - 0.5*fgkCoolingTubeSupportHeight);
1012 localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
1013 localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
1014 - 2.0*fgkSSDModuleStiffenerPosition[1]
1015 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
1016 + fgkCoolingTubeSupportWidth,
1017 localcoolingtubevect[0][0]->Z());
1018 localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
1019 + fgkCarbonFiberTriangleLength,
1020 localcoolingtubevect[0][0]->Y(),
1021 localcoolingtubevect[0][0]->Z());
1022 localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
1023 + fgkCarbonFiberTriangleLength,
1024 localcoolingtubevect[0][1]->Y(),
1025 localcoolingtubevect[0][1]->Z());
1026 localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
1027 - fgkCarbonFiberTriangleLength),
1028 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1029 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1030 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1031 - 0.5*(fgkCarbonFiberLowerSupportWidth
1032 + fgkSSDSensorCenterSupportLength
1033 - fgkSSDSensorCenterSupportThickness[0])
1034 + fgkSSDModuleStiffenerPosition[1]
1035 - 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
1036 - 0.5*fgkCoolingTubeSupportHeight);
1037 localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
1038 + fgkCarbonFiberTriangleLength,
1039 localcoolingtubevect[2][0]->Y(),
1040 localcoolingtubevect[2][0]->Z());
1041 localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
1042 - fgkCarbonFiberTriangleLength),
1043 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1044 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1045 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1046 - 0.5*(fgkCarbonFiberLowerSupportWidth
1047 + fgkSSDSensorCenterSupportLength
1048 - fgkSSDSensorCenterSupportThickness[0])
1049 + fgkSSDSensorLength
1050 - 0.5*fgkSSDModuleStiffenerPosition[1],
1051 - 0.5*fgkCoolingTubeSupportHeight);
1052 localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
1053 + fgkCarbonFiberTriangleLength,
1054 localcoolingtubevect[3][0]->Y(),
1055 - 0.5*fgkCoolingTubeSupportHeight);
1056 for(Int_t i=0; i<4; i++)
1057 for(Int_t j=0; j<2; j++){
1058 localcoolingtubetrans[i][j] =
1059 new TGeoTranslation(localcoolingtubevect[i][j]->X(),
1060 localcoolingtubevect[i][j]->Y(),
1061 localcoolingtubevect[i][j]->Z());
1062 fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
1063 * (*localcoolingtuberot));
1064 }
1065 /////////////////////////////////////////////////////////////
9b0c60ab 1066 // SSD End Ladder Cooling Tube Transformations
1067 /////////////////////////////////////////////////////////////
1068 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1069 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1070 TGeoTranslation** localendlladdercoolingtubetrans[2];
1071 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
1072 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
1073 for(Int_t i=0; i<2; i++)
1074 for(Int_t j=0; j<(i==0?6:4); j++)
1075 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1076 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1077 - fgkCoolingTubeSupportRmax)
1078 + fgkCarbonFiberJunctionLength,
1079 0.5*(fgkEndLadderMountingBlockPosition[0]
1080 - fgkendladdercoolingsupportdistance[0]),
1081 - 0.5*fgkCoolingTubeSupportHeight);
1082 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1083 - fgkCoolingTubeSupportRmax)
1084 - fgkCarbonFiberJunctionLength
1085 + fgkCarbonFiberTriangleLength,
1086 0.5*(fgkEndLadderMountingBlockPosition[0]
1087 - fgkendladdercoolingsupportdistance[0]),
1088 - 0.5*fgkCoolingTubeSupportHeight);
1089 localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1090 - fgkCoolingTubeSupportRmax)
1091 + fgkCarbonFiberJunctionLength,
1092 fgkEndLadderMountingBlockPosition[0]
1093 - fgkendladdercoolingsupportdistance[0]
1094 + 0.5*(fgkendladdercoolingsupportdistance[0]
1095 + fgkendladdercoolingsupportdistance[1]
1096 + fgkCoolingTubeSupportWidth),
1097 - 0.5*fgkCoolingTubeSupportHeight);
1098 localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
1099 - fgkCoolingTubeSupportRmax)
1100 - fgkCarbonFiberJunctionLength
1101 + fgkCarbonFiberTriangleLength,
1102 fgkEndLadderMountingBlockPosition[0]
1103 - fgkendladdercoolingsupportdistance[0]
1104 + 0.5*(fgkendladdercoolingsupportdistance[0]
1105 + fgkendladdercoolingsupportdistance[1]
1106 + fgkCoolingTubeSupportWidth),
1107 - 0.5*fgkCoolingTubeSupportHeight);
1108 localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
1109 - fgkCoolingTubeSupportRmax)
1110 + fgkCarbonFiberJunctionLength,
1111 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1112 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1113 - fgkEndLadderMountingBlockPosition[0]
1114 - fgkendladdercoolingsupportdistance[1]
1115 - fgkCoolingTubeSupportWidth),
1116 - 0.5*fgkCoolingTubeSupportHeight);
1117 localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
1118 - fgkCoolingTubeSupportRmax)
1119 - fgkCarbonFiberJunctionLength
1120 + fgkCarbonFiberTriangleLength,
1121 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1122 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1123 - fgkEndLadderMountingBlockPosition[0]
1124 - fgkendladdercoolingsupportdistance[1]
1125 - fgkCoolingTubeSupportWidth),
1126 - 0.5*fgkCoolingTubeSupportHeight);
1127 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1128 - fgkCoolingTubeSupportRmax)
1129 + fgkCarbonFiberJunctionLength,
1130 - 0.50 * (fgkMountingBlockToSensorSupport
1131 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1132 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1133 + fgkSSDSensorOverlap
1134 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1135 - fgkendladdercoolingsupportdistance[2]
1136 - fgkEndLadderMountingBlockPosition[1]
1137 - fgkCoolingTubeSupportWidth)
1138 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1139 - fgkendladdercoolingsupportdistance[2]
1140 - fgkCoolingTubeSupportWidth,
1141 - 0.5*fgkCoolingTubeSupportHeight);
1142 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1143 - fgkCoolingTubeSupportRmax)
1144 - fgkCarbonFiberJunctionLength
1145 + fgkCarbonFiberTriangleLength,
1146 - 0.50 * (fgkMountingBlockToSensorSupport
1147 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1148 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1149 + fgkSSDSensorOverlap
1150 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1151 - fgkendladdercoolingsupportdistance[2]
1152 - fgkEndLadderMountingBlockPosition[1]
1153 - fgkCoolingTubeSupportWidth)
1154 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1155 - fgkendladdercoolingsupportdistance[2]
1156 - fgkCoolingTubeSupportWidth,
1157 - 0.5*fgkCoolingTubeSupportHeight);
1158 localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1159 - fgkCoolingTubeSupportRmax)
1160 + fgkCarbonFiberJunctionLength,
1161 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1162 - 0.5*fgkendladdercoolingsupportdistance[2],
1163 - 0.5*fgkCoolingTubeSupportHeight);
1164 localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
1165 - fgkCoolingTubeSupportRmax)
1166 - fgkCarbonFiberJunctionLength
1167 + fgkCarbonFiberTriangleLength,
1168 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1169 - 0.5*fgkendladdercoolingsupportdistance[2],
1170 - 0.5*fgkCoolingTubeSupportHeight);
1171 fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
1172 fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
1173 for(Int_t i=0; i<2; i++)
1174 for(Int_t j=0; j<(i==0?6:4); j++){
1175 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1176 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1177 }
1178 /////////////////////////////////////////////////////////////
bf210566 1179 // SSD Hybrid Components Transformations
1180 /////////////////////////////////////////////////////////////
1181 const Int_t khybridmatrixnumber = 3;
1182 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1183 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1184 0.5*fgkSSDStiffenerWidth,
1185 0.5*fgkSSDStiffenerHeight);
1186 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1187 fgkSSDModuleStiffenerPosition[1],0.0);
1188
1189 localhybridtrans[2] = new TGeoTranslation(
1190 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1191 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1192 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1193 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1194 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1195 - fgkSSDSensorCenterSupportThickness[0]),
1196 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
ca86fdb4 1197 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
0fb26117 1198 - fgkSSDModuleVerticalDisalignment));
bf210566 1199 fhybridmatrix = new TGeoHMatrix();
1200 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1201 /////////////////////////////////////////////////////////////
1202 // SSD Cooling Block Transformations
1203 /////////////////////////////////////////////////////////////
1204 const Int_t kcoolingblockmatrixnumber = 4;
1205 TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
1206 localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
1207 - fgkCoolingTubeSupportRmin),0.0,
1208 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1209 localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
1210 - 0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
1211 0.0,fgkSSDStiffenerHeight);
1212 localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
1213 localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
1214 fcoolingblocksystematrix = new TGeoHMatrix();
1215 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
1216 fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
1217 /////////////////////////////////////////////////////////////
1218 // SSD Stiffener Flex Transformations
1219 /////////////////////////////////////////////////////////////
1220 const Int_t klocalflexmatrixnumber = 4;
1221 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1222 for(Int_t i=0; i<fgkflexnumber; i++)
1223 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1224 for(Int_t i=0; i<fgkflexnumber; i++)
1225 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1226 localflexmatrix[i][j] = new TGeoCombiTrans();
1227 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1228 - 2.*fgkSSDModuleStiffenerPosition[1]
1229 - fgkSSDStiffenerWidth;
1230 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1231 +0.5*fgkSSDStiffenerLength,
1232 0.5*fgkSSDStiffenerWidth,
1233 -0.5*fgkSSDStiffenerHeight
1234 -0.5*fgkSSDFlexHeight[0]);
1235 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1236 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1237 -0.5*fgkSSDStiffenerWidth,
1238 -0.5*fgkSSDStiffenerHeight
1239 -0.5*fgkSSDFlexHeight[0]);
1240 TGeoRotation* localflexrot = new TGeoRotation();
1241 localflexrot->SetAngles(180.,0.,0.);
1242 localflexmatrix[1][0]->SetRotation(localflexrot);
1243 for(Int_t i=0; i<fgkflexnumber; i++)
1244 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1245 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1246 for(Int_t i=0; i<fgkflexnumber; i++){
1247 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1248 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1249 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1250 }
bf210566 1251 /////////////////////////////////////////////////////////////
1252 // SSD End Flex Transformations
1253 /////////////////////////////////////////////////////////////
1254 TGeoRotation* localendflexrot = new TGeoRotation();
1255 localendflexrot->SetAngles(0.0,90.0,0.0);
1256 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1257 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1258 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1259 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1260 * TMath::DegToRad()*ssdflexradiusmax
1261 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 1262 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1263 - 0.1*fgkSSDFlexFullLength;
bf210566 1264 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1265 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1266 + fgkSSDFlexLength[2];
1267 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1268 0.5*fgkSSDFlexWidth[0],
1269 2.*fgkSSDStiffenerHeight
1270 + 0.5*fgkSSDFlexHeight[0]);
1271 localendflexmatrix->SetRotation(localendflexrot);
1272 for(Int_t i=0; i<fgkflexnumber; i++)
1273 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1274 /////////////////////////////////////////////////////////////
1275 // End Ladder Carbon Fiber Junction
1276 /////////////////////////////////////////////////////////////
1277 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1278 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1279 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1280 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1281 localendladdercarbonfiberjunctionmatrix[i]
1282 = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1283 localendladdercarbonfiberjunctionrot[i]
1284 = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1285 localendladdercarbonfiberjunctiontrans[i]
1286 = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1287 fendladdercarbonfiberjunctionmatrix[i]
1288 = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
d7599219 1289 }
bf210566 1290 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1291 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1292 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1293 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1294 }
1295 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1296 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1297 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1298 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1299 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1300 0.0,0.0);
1301 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1302 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1303 * SinD(fgkCarbonFiberTriangleAngle),
1304 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1305 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1306 }
1307 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1308 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1309 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1310 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1311 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1312 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1313 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1314 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1315 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1316 localendladdercarbonfiberjunctionglobalmatrix[i] =
1317 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1318 *localendladdercarbonfiberjunctionglobalrot[i]);
1319 }
1320 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1321 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1322 localendladdercarbonfiberjunctionmatrix[i][j] =
1323 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1324 *localendladdercarbonfiberjunctionrot[i][j]);
1325 fendladdercarbonfiberjunctionmatrix[i][j] =
1326 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1327 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1328 }
1329 /////////////////////////////////////////////////////////////
1330 // End Ladder Carbon Fiber Support
1331 /////////////////////////////////////////////////////////////
1332 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1333 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1334 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1335 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1336 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1337 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1338 }
1339 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1340 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1341 fendladdercarbonfibermatrix[i][j] =
1342 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1343 *(*fcarbonfibersupportmatrix[j]));
1344 /////////////////////////////////////////////////////////////
1345 // End Ladder SSD Mounting Block
1346 /////////////////////////////////////////////////////////////
1347 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1348 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1349 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1350 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1351 + fgkSSDMountingBlockLength[1])
1352 + 0.5*fgkCarbonFiberTriangleLength,
1353 fgkEndLadderMountingBlockPosition[i],
1354 - fgkSSDMountingBlockHeight[1]
1355 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1356 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1357 endladdermountingblockrot->SetAngles(0.,90.,0.);
1358 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1359 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1360 /////////////////////////////////////////////////////////////
1361 // End Ladder SSD Mounting Block Clip Matrix
1362 /////////////////////////////////////////////////////////////
1363 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1364 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1365
1366 TGeoRotation* localendladdercliprot = new TGeoRotation();
1367 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1368 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1369 - fgkSSDMountingBlockLength[1])
1370 + fgkSSDMountingBlockLength[0],0.,0.);
1371 localendladdercliprot->SetAngles(90.,180.,-90.);
1372 TGeoCombiTrans* localendladderclipcombitrans =
1373 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1374 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1375 for(Int_t j=0; j<2; j++){
1376 fendladdermountingblockclipmatrix[i][j] =
1377 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1378 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1379 }
bf210566 1380 /////////////////////////////////////////////////////////////
1381 // End Ladder Carbon Fiber Lower Support
1382 /////////////////////////////////////////////////////////////
1383 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1384 fendladderlowersupptrans[i] =
1385 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1386 + 0.5*fgkSSDMountingBlockWidth),
1387 - 0.5*fgkCarbonFiberLowerSupportHeight);
1388 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1389 fgkCarbonFiberLowerSupportVolumePosition[1]
1390 + fgkCarbonFiberLowerSupportVolumePosition[0],
1391 0.0);
1392 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1393 /////////////////////////////////////////////////////////////
1394 // Matrix for positioning Ladder into mother volume
1395 /////////////////////////////////////////////////////////////
1396 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1397 for(Int_t i=0; i<fgkladdernumber; i++)
1398 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1399 TGeoRotation* localladdermotherrot = new TGeoRotation();
1400 localladdermotherrot->SetAngles(0.,90.,0.);
1401 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1402 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1403 for(Int_t i=0; i<fgkladdernumber; i++){
1404 localladdermothertrans[i] = new TGeoTranslation(0.,
1405 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1406 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1407 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1408 * fgkCarbonFiberJunctionWidth,0.);
1409 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1410 *localladdermotherrot);
1411 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1412 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1413 }
44285dfa 1414 /////////////////////////////////////////////////////////////
bf210566 1415 // Ladder Cables Matrices
44285dfa 1416 /////////////////////////////////////////////////////////////
44285dfa 1417 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1418 + fgkSSDFlexHeight[1];
44285dfa 1419 Double_t ssdladdercabletransx[3];
1420 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1421 * SinD(2.*fgkSSDFlexAngle)
1422 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1423 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1424 - ssdladdercabletransx[0]
bf210566 1425 / SinD(2.*fgkSSDFlexAngle))
1426 * CosD(fgkSSDFlexAngle);
44285dfa 1427 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1428 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1429 - fgkSSDFlexLength[2]-TMath::Pi()
1430 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1431 - fgkSSDLadderCableWidth)
bf210566 1432 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1433 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1434 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1435 ssdladdercabletransx[1]
bf210566 1436 * TanD(fgkSSDFlexAngle),
44285dfa 1437 ssdladdercabletransx[2]
bf210566 1438 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1439 TGeoRotation* localladdercablerot[3];
bf210566 1440 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1441 localladdercablerot[0]->SetAngles(90.,0.,0.);
1442 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1443 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1444 * (*localladdercablerot[0]));
1445 ////////////////////////////////////////////
1446 // LocalLadderCableCombiTransMatrix
1447 ////////////////////////////////////////////
1448 const Int_t klocalladdersidecablesnumber = 2;
1449 const Int_t klocalladdercombitransnumber = 5;
1450 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1451 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1452 localladdercablecombitransmatrix[i] =
1453 new TGeoCombiTrans*[klocalladdercombitransnumber];
1454 ///////////////////////////////////////////
1455 // Left Side Ladder Cables Transformations
1456 ///////////////////////////////////////////
1457 localladdercablecombitransmatrix[0][0] =
d7599219 1458 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1459 0.,0.,NULL);
bf210566 1460 localladdercablecombitransmatrix[0][1] =
1461 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1462 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1463 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1464 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1465 - 0.5*(fgkCarbonFiberLowerSupportWidth
1466 + fgkSSDSensorCenterSupportLength
1467 - fgkSSDSensorCenterSupportThickness[0]),
1468 - (fgkSSDModuleCoolingBlockToSensor
1469 + 0.5*fgkCoolingTubeSupportHeight
1470 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1471 - fgkSSDChipHeight),NULL);
44285dfa 1472 localladdercablecombitransmatrix[0][2] =
d7599219 1473 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1474 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1475 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1476 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1477 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1478 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1479 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1480 new TGeoRotation("",180.,0.,0.));
44285dfa 1481 localladdercablecombitransmatrix[0][4] =
1482 new TGeoCombiTrans(-ssdladdercabletransx[0]
1483 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1484 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1485 0.,
1486 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1487 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1488 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1489 + ssdladdercabletransz[2],localladdercablerot[2]);
1490 ///////////////////////////////////////////
1491 // Rigth Side Ladder Cables Transformations
1492 ///////////////////////////////////////////
bf210566 1493 TGeoCombiTrans* localladdercablessdmodulematrix =
1494 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1495 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1496 fgkSSDStiffenerWidth,
1497 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1498 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1499 localladdercablecombitransmatrix[1][i] =
bf210566 1500 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1501 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1502 ///////////////////////////////////////////
bf210566 1503 // Setting LadderCableHMatrix
44285dfa 1504 ///////////////////////////////////////////
bf210566 1505 Int_t beamaxistrans[2][3];
1506 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1507 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1508 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1509 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1510 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1511 beamaxistrans[1][2] = beamaxistrans[1][0];
1512 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1513 TGeoRotation* laddercablerot = new TGeoRotation();
1514 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1515 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1516 Double_t* laddercabletransvector;
1517 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1518 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1519 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1520 }
1521 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1522 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1523 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1524 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1525 localladdercablehmatrix[i][j]->MultiplyLeft(
1526 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1527 }
1528 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1529 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1530 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1531 laddercabletransvector[1]
bf210566 1532 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1533 * fgkCarbonFiberJunctionWidth,
bf210566 1534 laddercabletransvector[2]);
1535 laddercablecombitrans->SetRotation(*laddercablerot);
1536 laddercablecombitrans->SetTranslation(*laddercabletrans);
1537 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1538 }
1539 fladdercablematrix[i][2] =
1540 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1541 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1542 fladdercablematrix[i][3] =
1543 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1544 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1545 }
1546 for(Int_t i=0; i<fgkladdercablesnumber; i++)
1547 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1548 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1549 ///////////////////////////////////////////
1550 // Setting Ladder HMatrix
1551 ///////////////////////////////////////////
1552 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1553 fgkSSDLay6SensorsNumber};
1554 for(Int_t i=0; i<fgkladdernumber; i++){
1555 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1556 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1557 fladdermatrix[i][j] = new TGeoHMatrix();
1558 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1559 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1560 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1561 }
1562 }
1563 ///////////////////////////////////////////
1564 // Setting SSD Sensor Matrix
1565 ///////////////////////////////////////////
1566 TGeoCombiTrans* localssdsensorcombitrans[2];
1567 TGeoRotation* localssdsensorrot = new TGeoRotation();
1568 localssdsensorrot->SetAngles(0.,90.,0.);
1569 TGeoTranslation* localssdsensortrans[2];
1570 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1571 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1572 fgkCarbonFiberJunctionWidth
1573 - fgkCarbonFiberLowerSupportWidth
1574 - fgkLowerSupportToSensorZ,
bf210566 1575 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1576 - fgkSSDModuleCoolingBlockToSensor
e21cdd03 1577 + (fgkSSDSensorSideSupportHeight[1]
0fb26117 1578 - fgkSSDSensorSideSupportHeight[0]));
bf210566 1579 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1580 fgkCarbonFiberJunctionWidth
1581 - fgkCarbonFiberLowerSupportWidth
1582 - fgkLowerSupportToSensorZ,
bf210566 1583 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1584 -fgkSSDModuleCoolingBlockToSensor);
bf210566 1585 for(Int_t i=0; i<2; i++)
1586 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1587 *localssdsensorrot);
1588 for(Int_t i=0; i<fgkladdernumber; i++){
1589 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1590 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1591 switch(i){
1592 case 0: //Ladder of Layer5
1593 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1594 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1595 *localssdsensorcombitrans[1])));
1596 break;
1597 case 1: //Ladder of Layer6
1598 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1599 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1600 *localssdsensorcombitrans[0])));
1601 break;
1602 }
1603 }
1604 }
1605 //////////////////////////
1606 // Setting SSD End Ladder
1607 //////////////////////////
1608 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1609 for(Int_t i=0; i<2; i++){
1610 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1611 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1612 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1613 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1614 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1615 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1616 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1617 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1618 }
1619 /////////////////////////////////////////////////////
1620 // Setting the CombiTransformation to pass ITS center
1621 /////////////////////////////////////////////////////
1622 Double_t itscentertransz[fgklayernumber];
1623 itscentertransz[0] = fgkSSDLay5LadderLength
1624 - fgkLay5CenterITSPosition;
1625 itscentertransz[1] = fgkSSDLay6LadderLength
1626 - fgkLay6CenterITSPosition;
1627 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1628 + 0.5*fgkCoolingTubeSupportHeight;
1629 TGeoRotation* itscenterrot[3];
1630 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1631 itscenterrot[0]->SetAngles(90.,180.,-90.);
1632 itscenterrot[1]->SetAngles(0.,90.,0.);
1633 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1634 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1635 for(Int_t i=0; i<fgklayernumber; i++)
1636 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1637 itssensortransy,
1638 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1639 - itscentertransz[i],itscenterrot[2]);
1640 TGeoRotation** locallayerrot[fgklayernumber];
1641 TGeoTranslation** locallayertrans[fgklayernumber];
1642 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1643 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1644 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1645 - fgkLay5CenterITSPosition);
1646 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1647 - fgkLay6CenterITSPosition);
1648 const Int_t kssdlayladdernumber[fgklayernumber] =
1649 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1650 for(Int_t i=0; i<fgklayernumber; i++){
1651 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1652 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1653 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1654 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1655 }
1656 Double_t layerladderangleposition[fgklayernumber] =
1657 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1658 Double_t layerradius = 0.;
1659 for(Int_t i=0; i<fgklayernumber; i++){
1660 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1661 switch(i){
1662 case 0: //Ladder of Layer5
1663 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1664 break;
1665 case 1: //Ladder of Layer6
1666 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1667 break;
1668 }
1669 locallayerrot[i][j] = new TGeoRotation();
1670 locallayertrans[i][j] = new TGeoTranslation();
1671 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1672 locallayertrans[i][j]->SetTranslation(layerradius
1673 * CosD(90.0+j*layerladderangleposition[i]),
1674 layerradius
1675 * SinD(90.0+j*layerladderangleposition[i]),0.);
1676 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1677 *locallayerrot[i][j]);
1678 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1679 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1680 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1681 }
1682 }
44285dfa 1683 /////////////////////////////////////////////////////////////
bf210566 1684 // Deallocating memory
44285dfa 1685 /////////////////////////////////////////////////////////////
bf210566 1686 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1687 delete carbonfiberot[i];
1688 delete localcarbonfibersupportmatrix[i];
1689 }
1690 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1691 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1692 delete localcarbonfiberjunctionmatrix[i][j];
1693 delete localcarbonfiberjunctionrot[i][j];
1694 delete localcarbonfiberjunctiontrans[i][j];
1695 }
1696 delete [] localcarbonfiberjunctionmatrix[i];
1697 delete [] localcarbonfiberjunctionrot[i];
1698 delete [] localcarbonfiberjunctiontrans[i];
1699 }
1700 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1701 delete localcarbonfiberlowersupportrans[i];
1702 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1703 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1704 delete localssdsensorsupportmatrix[i][j];
1705 delete localssdsensorsupportrot[i][j];
1706 delete localssdsensorsupportrans[i][j];
1707 }
1708 delete [] localssdsensorsupportmatrix[i];
1709 delete [] localssdsensorsupportrot[i];
1710 delete [] localssdsensorsupportrans[i];
1711 }
1712 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1713 delete localcoolingtubesupportmatrix[i];
1714 delete localcoolingtubesupportrot[i];
1715 delete localcoolingtubesupportrans[i];
1716 }
1717 for(Int_t i=0; i<4; i++){
1718 for(Int_t j=0; j<2; j++){
1719 delete localcoolingtubevect[i][j];
1720 delete localcoolingtubetrans[i][j];
1721 }
1722 delete [] localcoolingtubevect[i];
1723 delete [] localcoolingtubetrans[i];
1724 }
9b0c60ab 1725 delete endladdermountingblockrot;
bf210566 1726 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1727 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
1728 for(Int_t i=0; i<fgkflexnumber; i++){
1729 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1730 delete localflexmatrix[i][j];
1731 delete [] localflexmatrix[i];
1732 }
9b0c60ab 1733 delete localendlladdercoolingtuberot;
1734 for(Int_t i=0; i<2; i++){
1735 for(Int_t j=0; j<(i==0?6:4); j++)
1736 delete localendlladdercoolingtubetrans[i][j];
1737 delete [] localendlladdercoolingtubetrans[i];
1738 }
1739
bf210566 1740 delete localflexrot;
1741 delete localendflexrot;
1742 delete localendflexmatrix;
1743 for(Int_t i=0; i<fgkladdernumber; i++){
1744 delete localladdermothertrans[i];
1745 delete localladdermothercombitrans[i];
1746 }
1747 delete localladdermotherrot;
1748 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1749 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1750 delete localendladdercarbonfiberjunctionmatrix[i][j];
1751 delete localendladdercarbonfiberjunctionrot[i][j];
1752 delete localendladdercarbonfiberjunctiontrans[i][j];
1753 }
1754 delete [] localendladdercarbonfiberjunctionmatrix[i];
1755 delete [] localendladdercarbonfiberjunctionrot[i];
1756 delete [] localendladdercarbonfiberjunctiontrans[i];
1757 delete localendladdercarbonfiberjunctionglobalrot[i];
1758 delete localendladdercarbonfiberjunctionglobaltrans[i];
1759 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1760 }
9b0c60ab 1761 for(Int_t i=0; i<2; i++){
1762 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1763 delete [] localendladdercooltubetrans[i];
1764 }
1765 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1766 delete localendladdercarbonfibertrans[i];
1767 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1768 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1769 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1770 delete localladdercablecombitransmatrix[i][j];
1771 delete []localladdercablecombitransmatrix[i];
1772 }
9b0c60ab 1773 delete localendladdercliprot;
1774 delete localendladdercliptrans;
bf210566 1775 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1776 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1777 delete localladdercablehmatrix[i][j];
1778 delete []localladdercablehmatrix[i];
1779 }
1780 delete laddercablerot;
1781 delete laddercabletrans;
1782 delete laddercablecombitrans;
1783 delete localladdercablessdmodulematrix;
1784 delete localssdsensorrot;
1785 for(Int_t i=0; i<2; i++){
1786 delete localssdsensortrans[i];
1787 delete localssdsensorcombitrans[i];
1788 }
1789 for(Int_t i=0; i<fgklayernumber; i++){
1790 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1791 delete locallayerrot[i][j];
1792 delete locallayertrans[i][j];
1793 delete locallayercombitrans[i][j];
1794 }
1795 delete [] locallayerrot[i];
1796 delete [] locallayertrans[i];
1797 delete [] locallayercombitrans[i];
1798 delete localbeamaxistrans[i];
1799 }
1800 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1801 for(Int_t i=0; i<fgkladdernumber; i++){
1802 for(Int_t j=0; j<fgkladdernumber; j++)
1803 delete ladderglobalmatrix[i][j];
1804 delete [] ladderglobalmatrix[i];
1805 }
1806 /////////////////////////////////////////////////////////////
1807 fTransformationMatrices = kTRUE;
d7599219 1808}
bf210566 1809///////////////////////////////////////////////////////////////////////////////
1810void AliITSv11GeometrySSD::CreateBasicObjects(){
1811 /////////////////////////////////////////////////////////////
1812 // Method generating the Objects of SSD Geometry
1813 /////////////////////////////////////////////////////////////
1814 // SSD Sensor
1815 ///////////////////////////////////
1816 SetSSDSensor();
1817 /////////////////////////////////////////////////////////////
1818 // Carbon Fiber Support
1819 /////////////////////////////////////////////////////////////
1820 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1821 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1822 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1823 /////////////////////////////////////////////////////////////
bf210566 1824 // Carbon Fiber Junction
44285dfa 1825 /////////////////////////////////////////////////////////////
ca86fdb4 1826 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
bf210566 1827 /////////////////////////////////////////////////////////////
1828 // Carbon Fiber Lower Support
1829 /////////////////////////////////////////////////////////////
1830 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1831 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1832 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1833 /////////////////////////////
1834 // SSD Sensor Support
1835 /////////////////////////////
1836 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1837 new TGeoVolume*[fgkssdsensorsupportnumber];
44285dfa 1838 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
bf210566 1839 fgkSSDSensorSideSupportThickness[1]};
1840 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1841 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1842 fgkSSDSensorSideSupportHeight[i],
1843 fgkSSDSensorSideSupportWidth,
1844 sidesupporthickness);
1845 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1846 fgkSSDSensorCenterSupportHeight[i],
1847 fgkSSDSensorCenterSupportWidth,
1848 sidesupporthickness);
1849 }
1850 /////////////////////////////////////////////////////////////
1851 // SSD Cooling Tube Support
1852 /////////////////////////////////////////////////////////////
1853 Int_t edgesnumber = 16;
1854 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1855 /////////////////////////////////////////////////////////////
1856 // SSD Hybrid
1857 /////////////////////////////////////////////////////////////
1858 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1859 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1860 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1861 /////////////////////////////////////////////////////////////
1862 // SSD Cooling Block System
1863 /////////////////////////////////////////////////////////////
1864 fssdcoolingblocksystem = GetCoolingBlockSystem();
1865 /////////////////////////////////////////////////////////////
1866 // SSD Cooling Tube
1867 /////////////////////////////////////////////////////////////
1868 TList* coolingtubelist = GetCoolingTubeList();
1869 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
1870 fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
9b0c60ab 1871 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
1872 fendladdercoolingtube[i] =
1873 (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
bf210566 1874 /////////////////////////////////////////////////////////////
1875 // SSD Flex
1876 /////////////////////////////////////////////////////////////
1877 fssdstiffenerflex = GetSSDStiffenerFlex();
1878 fssdendflex = GetSSDEndFlex();
1879 ///////////////////////////////////
1880 // End Ladder Carbon Fiber Junction
1881 ///////////////////////////////////
1882 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1883 fendladdercarbonfiberjunction[i] =
1884 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1885 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1886 fendladdercarbonfiberjunction[i][0] =
ca86fdb4 1887 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
bf210566 1888 fendladdercarbonfiberjunction[i][1] =
ca86fdb4 1889 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
bf210566 1890 }
1891 ///////////////////////////////////
1892 // End Ladder Mounting Block
1893 ///////////////////////////////////
1894 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1895 ///////////////////////////////////
1896 // End Ladder Mounting Block
1897 ///////////////////////////////////
1898 fendladdermountingblockclip = GetMountingBlockClip();
1899 ///////////////////////////////////
1900 // Ladder Support
1901 ///////////////////////////////////
1902 TList* laddersupportlist = GetMountingBlockSupport(20);
1903 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1904 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1905 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1906 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
bf210566 1907 /////////////////////////////////////////////////////////////
1908 // Deallocating memory
44285dfa 1909 /////////////////////////////////////////////////////////////
bf210566 1910 delete carbonfibersupportlist;
1911 delete carbonfiberlowersupportlist;
1912 delete ssdhybridcomponentslist;
9b0c60ab 1913 delete laddersupportlist;
44285dfa 1914 /////////////////////////////////////////////////////////////
bf210566 1915 fBasicObjects = kTRUE;
1916}
1917/////////////////////////////////////////////////////////////////////////////////
1918void AliITSv11GeometrySSD::SetSSDSensor(){
1919 ////////////////////////////////////////////////////////////////
1920 // Method generating SSD Sensors: it sets the private variables
1921 // fSSDSensor5, fSSDSensor6
1922 ////////////////////////////////////////////////////////////////
44285dfa 1923 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1924 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1925 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
44285dfa 1926 0.5*ssdsensitivewidth,
bf210566 1927 0.5*fgkSSDSensorHeight,
1928 0.5*ssdsensitivelength);
1929 TGeoVolume* ssdsensorsensitiveLay5 =
02d4acf9 1930 new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1931 TGeoVolume* ssdsensorsensitiveLay6 =
02d4acf9 1932 new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1933 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1934 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
44285dfa 1935 TGeoBBox* ssdsensorinsensitiveshape[2];
1936 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1937 0.5*fgkSSDSensorInsensitiveWidth,
bf210566 1938 0.5*fgkSSDSensorHeight,
1939 0.5*fgkSSDSensorLength);
44285dfa 1940 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
44285dfa 1941 0.5*ssdsensitivewidth,
bf210566 1942 0.5*fgkSSDSensorHeight,
1943 0.5*fgkSSDSensorInsensitiveWidth);
44285dfa 1944 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1945 "SSDSensorInsensitive2"};
44285dfa 1946 TGeoVolume* ssdsensorinsensitive[2];
1947 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1948 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1949 fSSDSensorMedium);
1950 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1951 }
bf210566 1952 /////////////////////////////////////////////////////////////
1953 // Virtual Volume containing SSD Sensor
1954 /////////////////////////////////////////////////////////////
1955 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1956 0.5*fgkSSDSensorWidth,
1957 0.5*fgkSSDSensorHeight,
1958 0.5*fgkSSDSensorLength);
ef9451a3 1959 fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
bf210566 1960 fSSDAir);
ef9451a3 1961 fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
bf210566 1962 fSSDAir);
1963 /////////////////////////////////////////////////////////////
1964 for(Int_t i=0; i<4; i++){
1965 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1966 ssdsensorinsensitive[1],i<2?1:2,
1967 new TGeoTranslation(
1968 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1969 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1970 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1971 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1972 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
44285dfa 1973 ssdsensorinsensitive[1],i<2?1:2,
bf210566 1974 new TGeoTranslation(
1975 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1976 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1977 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1978 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1979 }
1980 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1981 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1982}
bf210566 1983///////////////////////////////////////////////////////////////////////////////
1984TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1985 /////////////////////////////////////////////////////////////
1986 // Method generating the Carbon Fiber Support
1987 /////////////////////////////////////////////////////////////
1988 const Int_t kvertexnumber = 4;
1989 const Int_t kshapesnumber = 2;
1990 TVector3** vertexposition[kshapesnumber];
1991 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1992 Double_t carbonfibersupportxaxisEdgeproj =
1993 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1994 * TMath::DegToRad());
1995 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1996 / fgkCarbonFiberSupportXAxisLength);
1997 /////////////////////
1998 //Vertex Positioning
1999 ////////////////////
2000 vertexposition[0][0] = new TVector3();
2001 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
2002 fgkCarbonFiberSupportYAxisLength);
2003 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
2004 carbonfibersupportxaxisEdgeproj
2005 * TMath::Tan(theta));
2006 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
2007 - carbonfibersupportxaxisEdgeproj,
2008 fgkCarbonFiberSupportYAxisLength
2009 - vertexposition[0][2]->Y());
2010 ////////////////////////////////////////////////////
2011 //Setting the parameters for Isometry Transformation
2012 ////////////////////////////////////////////////////
2013 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
2014 + fgkCarbonFiberSupportTopEdgeDist[0]
2015 + fgkCarbonFiberSupportWidth);
2016 Double_t* param = new Double_t[4];
2017 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
2018 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
2019 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
2020 (GetReflection(vertexposition[0][j],param))->Y());
a6e0ebfe 2021 const char* carbonfibersupportshapename[kshapesnumber] =
bf210566 2022 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
a6e0ebfe 2023 const char* carbonfibersupportname[kshapesnumber] =
bf210566 2024 {"CarbonFiberSupport1","CarbonFiberSupport2"};
2025 TGeoArb8* carbonfibersupportshape[kshapesnumber];
2026 TGeoVolume* carbonfibersupport[kshapesnumber];
2027 TList* carbonfibersupportlist = new TList();
2028 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
2029 Double_t carbonfibersupportheight =
2030 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
2031 *TMath::DegToRad());
2032 for(Int_t i = 0; i< kshapesnumber; i++){
2033 carbonfibersupportshape[i] =
2034 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
2035 carbonfibersupportshapename[i],i==0 ? 1: -1);
2036 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
2037 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
2038 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
2039 carbonfibersupportlist->Add(carbonfibersupport[i]);
2040 }
2041 /////////////////////////////////////////////////////////////
2042 // Deallocating memory
2043 /////////////////////////////////////////////////////////////
2044 for(Int_t i=0; i< kshapesnumber; i++){
2045 for(Int_t j=0; j< kvertexnumber; j++)
2046 delete vertexposition[i][j];
2047 delete [] vertexposition[i];
2048 }
2049 delete [] param;
44285dfa 2050 /////////////////////////////////////////////////////////////
bf210566 2051 return carbonfibersupportlist;
d7599219 2052}
2053/////////////////////////////////////////////////////////////////////////////////
bf210566 2054TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 2055 /////////////////////////////////////////////////////////////
bf210566 2056 // Method generating SSD Carbon Fiber Junction
44285dfa 2057 /////////////////////////////////////////////////////////////
bf210566 2058 const Int_t kvertexnumber = 6;
2059 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
d4ff3e0a 2060 Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
2061 * TMath::DegToRad()),-1.,0.,0.};
bf210566 2062 TVector3* vertex[kvertexnumber];
2063 vertex[0] = new TVector3();
2064 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2065 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2066 * TMath::DegToRad()),
2067 fgkCarbonFiberJunctionEdge[0]
2068 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
2069 * TMath::DegToRad()));
2070 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
2071 fgkCarbonFiberJunctionEdge[1]);
2072 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
2073 vertex[1] = GetReflection(vertex[5],reflectionparam);
2074 vertex[2] = GetReflection(vertex[4],reflectionparam);
2075 Double_t xvertexpoints[6], yvertexpoints[6];
2076 for(Int_t i=0; i<kvertexnumber; i++)
2077 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
2078 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2079 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
2080 carbonfiberjunctionshape->DefineSection(1,0.5*width);
2081 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
2082 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
2083 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
2084 /////////////////////////////////////////////////////////////
2085 // Deallocating memory
2086 /////////////////////////////////////////////////////////////
2087 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
2088 /////////////////////////////////////////////////////////////
2089 return carbonfiberjunction;
2090}
2091////////////////////////////////////////////////////////////////////////////////
2092TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
2093 /////////////////////////////////////////////////////////////
2094 // Method generating the Carbon Fiber Lower Support
2095 /////////////////////////////////////////////////////////////
2096 const Int_t kvertexnumber = 4;
2097 const Int_t kshapesnumber = 2;
2098 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
2099 fgkCarbonFiberLowerSupportWidth};
2100 TVector3** vertexposition[kshapesnumber];
2101 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2102 new TVector3*[kvertexnumber];
2103 //First Shape Vertex Positioning
2104 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2105 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2106 - fgkCarbonFiberLowerSupportLowerLenght);
2107 vertexposition[0][2] = new TVector3();
2108 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2109 //Second Shape Vertex Positioning
2110 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2111 - fgkCarbonFiberLowerSupportVolumePosition[0])
2112 / fgkCarbonFiberTriangleLength);
2113 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2114 vertexposition[0][0]->X()*TMath::Tan(theta)
2115 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2116 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2117 vertexposition[0][1]->X()*TMath::Tan(theta)
2118 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2119 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2120 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2121 fgkCarbonFiberLowerSupportVolumePosition[1]);
a6e0ebfe 2122 const char* carbonfiberlowersupportshapename[kshapesnumber] =
bf210566 2123 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
a6e0ebfe 2124 const char* carbonfiberlowersupportname[kshapesnumber] =
bf210566 2125 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2126 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2127 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2128 TList* carbonfiberlowersupportlist = new TList();
2129 for(Int_t i = 0; i< kshapesnumber; i++){
2130 carbonfiberlowersupportshape[i] =
2131 GetArbShape(vertexposition[i],width,
2132 fgkCarbonFiberLowerSupportHeight,
2133 carbonfiberlowersupportshapename[i]);
2134 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2135 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2136 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2137 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2138 }
2139 /////////////////////////////////////////////////////////////
2140 // Deallocating memory
2141 /////////////////////////////////////////////////////////////
2142 for(Int_t i=0; i< kshapesnumber; i++){
2143 for(Int_t j=0; j< kvertexnumber; j++)
2144 delete vertexposition[i][j];
2145 delete [] vertexposition[i];
2146 }
2147 /////////////////////////////////////////////////////////////
2148 return carbonfiberlowersupportlist;
2149}
2150///////////////////////////////////////////////////////////////////////////////
2151TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2152 Double_t width, Double_t* thickness)const{
2153 /////////////////////////////////////////////////////////////
2154 // Method generating the Sensor Support
2155 /////////////////////////////////////////////////////////////
2156 const Int_t kvertexnumber = 6;
2157 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2158 TVector3* vertexposition[kvertexnumber];
2159 vertexposition[0] = new TVector3();
2160 vertexposition[1] = new TVector3(0.0,length);
2161 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2162 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2163 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2164 vertexposition[5] = new TVector3(vertexposition[4]->X());
2165 Double_t xvertexpoints[6], yvertexpoints[6];
2166 for(Int_t i=0; i<kvertexnumber; i++)
2167 xvertexpoints[i] = vertexposition[i]->X(),
2168 yvertexpoints[i] = vertexposition[i]->Y();
2169 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2170 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2171 ssdsensorsupportshape->DefineSection(1,0.5*width);
2172 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2173 ssdsensorsupportshape,fSSDSensorSupportMedium);
2174 /////////////////////////////////////////////////////////////
2175 // Deallocating memory
2176 /////////////////////////////////////////////////////////////
2177 for (Int_t i=0; i<kvertexnumber; i++)
2178 delete vertexposition[i];
2179 /////////////////////////////////////////////////////////////
2180 return ssdsensorsupport;
2181}
2182////////////////////////////////////////////////////////////////////////////////
2183TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2184 /////////////////////////////////////////////////////////////
2185 // Method generating the Cooling Tube Support
2186 /////////////////////////////////////////////////////////////
2187 if(nedges%2!=0) nedges--;
2188 const Int_t kvertexnumber = nedges+5;
2189 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2190 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2191 Double_t angle = 90.+phi;
2192 Double_t psi = 90.-phi;
2193 ///////////////////////////////////////
2194 // Vertex Positioning for TGeoXTru
2195 ///////////////////////////////////////
2196 TVector3** vertexposition = new TVector3*[kvertexnumber];
2197 vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
2198 fgkCoolingTubeSupportRmin*SinD(angle));
2199 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2200 fgkCoolingTubeSupportRmax*SinD(angle));
2201 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2202 fgkCoolingTubeSupportRmax);
2203 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2204 fgkCoolingTubeSupportRmax);
2205 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2206 vertexposition[1]->Y());
2207 for(Int_t i=0; i<nedges; i++)
2208 vertexposition[i+5] =
2209 new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
2210 fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
2211 ///////////////////////////////////////////////////////////////////////
2212 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2213 ///////////////////////////////////////////////////////////////////////
2214 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2215 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2216 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2217 for(Int_t i=0; i<kvertexnumber; i++){
2218 xvertexpoints[i] = vertexposition[i]->X();
2219 yvertexpoints[i] = vertexposition[i]->Y();
2220 }
2221 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2222 yvertexpoints);
2223 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2224 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2225 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2226 coolingtubesupportarcshape,
2227 fSSDTubeHolderMedium);
2228 coolingtubesupportarc->SetLineColor(fColorG10);
2229 //////////////////////////////////////////////////////////////////////////
2230 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2231 //////////////////////////////////////////////////////////////////////////
2232 TGeoTubeSeg* coolingtubesupportsegshape =
2233 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2234 fgkCoolingTubeSupportRmax,
2235 0.5*fgkCoolingTubeSupportWidth,
2236 phi,360-phi);
2237 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2238 coolingtubesupportsegshape,
2239 fSSDTubeHolderMedium);
2240 coolingtubesupportseg->SetLineColor(fColorG10);
2241 //////////////////////////////////////////////////////////////////////////
2242 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2243 //////////////////////////////////////////////////////////////////////////
2244 Double_t* boxorigin = new Double_t[3];
2245 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2246 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2247 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2248 0.5*fgkCoolingTubeSupportHeight,
2249 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2250 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2251 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2252 coolingtubesupportbox->SetLineColor(fColorG10);
2253 //////////////////////////////////////////////////////////////////////////
2254 // Cooling Tube for Cooling Tube Support
2255 //////////////////////////////////////////////////////////////////////////
2256 TGeoXtru* coolingtubearcshape[2];
2257 coolingtubearcshape[0] = new TGeoXtru(2);
2258 Double_t* xvert = new Double_t[nedges+2];
2259 Double_t* yvert = new Double_t[nedges+2];
2260 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2261 ////////////////////////////////////////
2262 // Positioning the vertices for TGeoXTru
2263 ////////////////////////////////////////
2264 xvert[0] = 0., yvert[0] = 0.;
2265 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2266 for(Int_t i=0; i< nedges; i++)
2267 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2268 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2269 ////////////////////////////////////////
2270 // Defining TGeoXTru PolyGone
2271 ////////////////////////////////////////
2272 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2273 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2274 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2275 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2276 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2277 TGeoVolume* coolingtubearc[2];
2278 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2279 coolingtubearcshape[0],fSSDCoolingTubeWater);
2280 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2281 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2282 coolingtubearc[0]->SetLineColor(fColorWater);
2283 coolingtubearc[1]->SetLineColor(fColorPhynox);
2284 ////////////////////////////////////////////
2285 // Defining TGeoTubeSeg Part of Cooling Tube
2286 ////////////////////////////////////////////
2287 TGeoTubeSeg* coolingtubesegshape[2];
2288 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2289 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2290 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2291 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2292 TGeoVolume* coolingtubeseg[2];
2293 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2294 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2295 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2296 coolingtubesegshape[1],fSSDCoolingTubeWater);
2297 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2298 coolingtubeseg[1]->SetLineColor(fColorWater);
2299 /////////////////////////////////////////////////////////////
2300 // Virtual Volume containing Cooling Tube Support
2301 /////////////////////////////////////////////////////////////
2302 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2303 const Int_t kvirtualvertexnumber = 8;
2304 TVector3* virtualvertex[kvirtualvertexnumber];
2305 ////////////////////////////////////////
2306 // Positioning the vertices for TGeoXTru
2307 ////////////////////////////////////////
2308 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2309 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2310 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2311 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2312 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2313 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2314 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2315 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2316 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2317 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2318 xmothervertex[i] = virtualvertex[i]->X(),
2319 ymothervertex[i] = virtualvertex[i]->Y();
2320 ////////////////////////////////////////
2321 // Defining TGeoXTru PolyGone
2322 ////////////////////////////////////////
2323 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2324 ymothervertex);
2325 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2326 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2327 TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2328 virtualCoolingTubeSupportShape,fSSDAir);
2329 ////////////////////////////////////////
2330 // Positioning Volumes in Virtual Volume
2331 ////////////////////////////////////////
2332 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2333 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2334 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2335 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2336 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2337 virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2338 virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2339 virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2340 virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2341 /////////////////////////////////////////////////////////////
2342 // Deallocating memory
2343 /////////////////////////////////////////////////////////////
2344 delete [] vertexposition;
3e008bd7 2345 delete [] xvertexpoints;
2346 delete [] yvertexpoints;
2347 delete [] xvert;
2348 delete [] yvert;
bf210566 2349 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2350 delete virtualvertex[i];
2351 /////////////////////////////////////////////////////////////
2352 return virtualcoolingtubesupport;
2353}
2354/////////////////////////////////////////////////////////////////////////////////
2355TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2356 /////////////////////////////////////////////////////////////
2357 // Method generating List containing SSD Hybrid Components
2358 /////////////////////////////////////////////////////////////
2359 TList* ssdhybridlist = new TList();
2360 const Int_t kssdstiffenernumber = 2;
2361 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2362 - 2.*fgkSSDModuleStiffenerPosition[1]
2363 - fgkSSDStiffenerWidth;
2364 Double_t ssdchipcablesradius[kssdstiffenernumber];
2365 for(Int_t i=0; i<kssdstiffenernumber; i++)
2366 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2367 - fgkSSDChipCablesHeight[0]
2368 - fgkSSDChipCablesHeight[1]);
2369 /////////////////////////////////////////////////////////////
2370 // Mother Volumes Containers
2371 /////////////////////////////////////////////////////////////
2372 const Int_t kmothernumber = 2;
2373 const Int_t kmothervertexnumber = 12;
2374 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2375 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2376 ///////////////////////
2377 // Setting the vertices
2378 ///////////////////////
2379 xmothervertex[0][0] = -0.5*fgkSSDStiffenerLength;
2380 xmothervertex[0][1] = xmothervertex[0][0];
2381 xmothervertex[0][2] = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
2382 xmothervertex[0][3] = xmothervertex[0][2];
2383 xmothervertex[0][4] = xmothervertex[0][0];
2384 xmothervertex[0][5] = xmothervertex[0][4];
2385 xmothervertex[0][6] = -xmothervertex[0][0];
2386 xmothervertex[0][7] = xmothervertex[0][6];
2387 xmothervertex[0][8] = -xmothervertex[0][2];
2388 xmothervertex[0][9] = xmothervertex[0][8];
2389 xmothervertex[0][10] = xmothervertex[0][7];
2390 xmothervertex[0][11] = xmothervertex[0][10];
2391 for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
2392 for(Int_t i = 0; i<kmothernumber; i++){
2393 ymothervertex[i][0] = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
2394 + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
2395 ymothervertex[i][1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
2396 ymothervertex[i][2] = ymothervertex[i][1];
2397 ymothervertex[i][3] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
2398 ymothervertex[i][4] = ymothervertex[i][3];
2399 ymothervertex[i][5] = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
2400 ymothervertex[i][6] = ymothervertex[i][5];
2401 ymothervertex[i][7] = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
2402 ymothervertex[i][8] = ymothervertex[i][7];
2403 ymothervertex[i][9] = 0.5*fgkSSDStiffenerWidth;
2404 ymothervertex[i][10] = ymothervertex[i][9];
2405 ymothervertex[i][11] = ymothervertex[i][0];
2406 }
2407 TGeoXtru* ssdhybridmothershape[kmothernumber];
ca86fdb4 2408// TGeoVolume* ssdhybridmother[kmothernumber];
2409 TGeoVolumeAssembly* ssdhybridmother[kmothernumber];
bf210566 2410 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2411 for(Int_t i=0; i<kmothernumber; i++){
2412 ssdhybridmothershape[i] = new TGeoXtru(2);
2413 ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
2414 ymothervertex[i]);
2415 ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2416 -fgkSSDChipCablesHeight[i+2]);
2417 ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
ca86fdb4 2418// ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
2419// fSSDAir);
2420 ssdhybridmother[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
bf210566 2421 }
2422 /////////////////////////////////////////////////////////////
2423 // SSD Stiffener
2424 /////////////////////////////////////////////////////////////
2425 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2426 0.5*fgkSSDStiffenerLength,
ca86fdb4 2427 0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
bf210566 2428 0.5*fgkSSDStiffenerHeight);
2429 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2430 fSSDStiffenerMedium);
2431 ssdstiffener->SetLineColor(fColorStiffener);
2432 TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
2433 for(Int_t i=0; i<kssdstiffenernumber; i++)
2434 ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
2435 /////////////////////////////////////////////////////////////
2436 // SSD Chip System
2437 /////////////////////////////////////////////////////////////
2438 TList* ssdchipsystemlist = GetSSDChipSystem();
2439 Double_t ssdchipseparation = fgkSSDSensorLength
2440 - 2.*fgkSSDModuleStiffenerPosition[1]
2441 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
2442 - 0.5*fgkSSDChipWidth);
2443 Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
2444 + fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
2445 TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
2446 - 0.5*ssdchipsystemlength,
2447 0.5*(ssdstiffenerseparation-ssdchipseparation),
2448 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
2449////////////////////////////
2450// Capacitor 0603-2200 nF
2451///////////////////////////
2452 const Int_t knapacitor0603number = 5;
2453 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
2454 0.5*fgkSSDCapacitor0603Length,
9f5fafaf 2455 0.5*(fgkSSDCapacitor0603Width),
bf210566 2456 0.5*fgkSSDCapacitor0603Height);
2457 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2458 fSSDStiffener0603CapacitorMedium);
2459 capacitor0603->SetLineColor(fColorAl);
bf210566 2460 for(Int_t i=0; i<kmothernumber; i++){
2461 for(Int_t j=0; j<kssdstiffenernumber; j++){
2462 ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
2463 for(Int_t k=1; k<knapacitor0603number+1; k++){
9f5fafaf 2464 ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
2465 new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
2466 j*ssdstiffenerseparation
2467 + 0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
2468 + (j==0? -1:+1)*fgkSSDCapacitor0603Width),
2469 - 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
bf210566 2470 }
2471 }
2472 ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
2473 ssdhybridlist->Add(ssdhybridmother[i]);
2474 }
2475/////////////////////////////////////////////////////////////
2476// Mother Volume Containing Capacitor Part
2477/////////////////////////////////////////////////////////////
2478 const Int_t kcapacitormothernumber = 8;
2479 Double_t xcapacitorvertex[kcapacitormothernumber];
2480 Double_t ycapacitorvertex[kcapacitormothernumber];
2481 ///////////////////////
2482 // Setting the vertices
2483 ///////////////////////
2484 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2485 xcapacitorvertex[1] = xcapacitorvertex[0];
2486 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2487 xcapacitorvertex[3] = xcapacitorvertex[2];
2488 xcapacitorvertex[4] = xcapacitorvertex[0];
2489 xcapacitorvertex[5] = xcapacitorvertex[0];
2490 xcapacitorvertex[6] = -xcapacitorvertex[0];
2491 xcapacitorvertex[7] = xcapacitorvertex[6];
2492 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2493 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2494 ycapacitorvertex[2] = ycapacitorvertex[1];
2495 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2496 ycapacitorvertex[4] = ycapacitorvertex[3];
2497 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2498 ycapacitorvertex[6] = ycapacitorvertex[5];
2499 ycapacitorvertex[7] = ycapacitorvertex[0];
2500 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2501 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2502 ycapacitorvertex);
2503 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2504 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
ca86fdb4 2505// TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2506// fSSDAir);
2507 TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
d7599219 2508////////////////////////////
bf210566 2509// Connector
d7599219 2510///////////////////////////
bf210566 2511 const Int_t kssdconnectornumber = 2;
2512 TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2513 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2514 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2515 + fgkSSDConnectorAlHeight};
2516 const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2517 TGeoVolume* ssdconnector[kssdconnectornumber];
2518 for(Int_t i=0; i<kssdconnectornumber; i++){
2519 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2520 0.5*fgkSSDConnectorWidth,
2521 0.5*((1-i)*fgkSSDConnectorAlHeight
2522 + i*fgkSSDConnectorNiHeight),
2523 i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2524 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2525 i==0 ? fSSDAlTraceFlexMedium
2526 : fSSDStiffenerConnectorMedium);
2527 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2528 }
2529 TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2530 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2531 + fgkSSDConnectorPosition[0]
2532 - fgkSSDConnectorSeparation
2533 - 1.5*fgkSSDConnectorLength,
2534 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2535 - fgkSSDConnectorPosition[1]
2536 - ssdconnectorshape[0]->GetDY(),0.0);
2537 ssdconnectortrans[1] = new TGeoTranslation(
2538 - ssdstiffenershape->GetDX()
2539 + fgkSSDConnectorPosition[0]
2540 - 0.5*fgkSSDConnectorLength,
2541 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2542 - fgkSSDConnectorPosition[1]
2543 - ssdconnectorshape[0]->GetDY(),0.0);
2544 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2545 - fgkSSDConnectorPosition[0]
2546 + fgkSSDConnectorSeparation
2547 + 1.5*fgkSSDConnectorLength,
2548 -(ssdstiffenershape->GetDY()
2549 - fgkSSDConnectorPosition[1]
2550 - ssdconnectorshape[0]->GetDY()),0.0);
2551 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2552 - fgkSSDConnectorPosition[0]
2553 + 0.5*fgkSSDConnectorLength,
2554 -(ssdstiffenershape->GetDY()
2555 - fgkSSDConnectorPosition[1]
2556 - ssdconnectorshape[0]->GetDY()),0.0);
2557 for(Int_t i=0; i<2*kssdconnectornumber; i++)
2558 for(Int_t j=0; j<kssdconnectornumber; j++)
2559 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2560////////////////////////////
2561// Capacitor 1812-330 nF
2562///////////////////////////
2563 Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2564 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2565 0.5*fgkSSDCapacitor1812Length,
2566 0.5*fgkSSDCapacitor1812Width,
bf210566 2567 0.5*fgkSSDCapacitor1812Height,
2568 ssdcapacitor1812origin);
44285dfa 2569 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2570 fSSDStiffener1812CapacitorMedium);
2571 capacitor1812->SetLineColor(fColorAl);
bf210566 2572 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2573 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2574 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2575 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
d7599219 2576////////////////////////////
2577//Hybrid Wire
2578////////////////////////////
44285dfa 2579 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2580 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2581 - fgkSSDConnectorSeparation;
44285dfa 2582 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2583 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
44285dfa 2584 Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
2585 + TMath::Power(wirey,2));
2586 Double_t wireangle = TMath::ATan(wirex/wirey);
2587 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2588 fgkSSDWireRadius, 0.5*ssdwireradius);
2589 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2590 fSSDStiffenerHybridWireMedium);
2591 hybridwire->SetLineColor(fColorPhynox);
2592 TGeoCombiTrans* hybridwirecombitrans[2];
2593 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2594 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2595 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2596 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2597 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2598 ssdstiffenershape->GetDZ()
2599 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
d7599219 2600 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2601 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2602 0.0,
2603 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2604 0.0,
2605 new TGeoRotation("HybridWireRot2",
2606 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2607 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2608 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2609 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2610 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2611 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2612 /////////////////////////////////////////////////////////////
bf210566 2613 // Deallocating memory
44285dfa 2614 /////////////////////////////////////////////////////////////
bf210566 2615 delete hybridwirecombitrans[0];
2616 delete hybridwirecombitrans[1];
2617 delete ssdchipsystemlist;
2618 return ssdhybridlist;
2619 /////////////////////////////////////////////////////////////
2620}
2621///////////////////////////////////////////////////////////////////////////////
2622TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2623 /////////////////////////////////////////////////////////////
2624 // SSD Cooling Block System
2625 /////////////////////////////////////////////////////////////
2626 // SSD Cooling Block and Cooling Tube Transformations
2627 /////////////////////////////////////////////////////////////
2628 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2629 localcoolingblockrot->SetAngles(0.,90.,0.);
535e8862 2630 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
bf210566 2631 TVector3* coolingblocktransvector;
2632 coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2633 + fgkSSDCoolingBlockLength,
2634 fgkSSDSensorLength
2635 - 2.*fgkSSDModuleStiffenerPosition[1]
2636 - fgkSSDCoolingBlockWidth);
2637 const Int_t kcoolingblocktransnumber = 2;
2638 const Int_t kcoolingblocknumber = 4;
2639 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2640 TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2641 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2642 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2643 TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2644 localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
535e8862 2645 0.5*fgkSSDCoolingBlockWidth,
2646 fgkSSDCoolingBlockHoleCenter);
2647 TGeoCombiTrans localcoolingtubematrix (*localcoolingtubetrans,*localcoolingtuberot);
bf210566 2648 Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2649 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
535e8862 2650 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2651 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X()+2*coolingtubedistance,
2652 j*coolingblocktransvector->Y(),
2653 - 0.5*(fgkSSDCoolingBlockHoleCenter
2654 + fgkCoolingTubeRmax));
2655 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
2656 coolingtubematrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingtubematrix);
2657 }
d7599219 2658 }
bf210566 2659 /////////////////////////////////////////////////////////////
2660 // Virtual Volume containing CoolingBlock System
2661 /////////////////////////////////////////////////////////////
2662 TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2663 const Int_t kmothervertexnumber = 16;
2664 Double_t xmothervertex[kmothervertexnumber];
2665 Double_t ymothervertex[kmothervertexnumber];
2666 ///////////////////////
2667 // Setting the vertices
2668 ///////////////////////fgkCoolingTubeSupportRmax
2669 xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2670 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2671 + fgkSSDCoolingBlockWidth;
2672 xmothervertex[2] = coolingblocktransvector->X()
2673 + fgkSSDCoolingBlockLength
2674 + 4*coolingtubedistance;
2675 ymothervertex[2] = ymothervertex[1];
2676 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2677 xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2678 ymothervertex[4] = ymothervertex[0];
2679 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2680 xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2681 ymothervertex[6] = ymothervertex[5];
2682 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2683 - fgkSSDCoolingBlockWidth;
2684 xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2685 xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2686 - coolingtubedistance;
2687 xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2688 ymothervertex[10] = ymothervertex[9];
2689 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2690 xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2691 xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2692 xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2693 ymothervertex[14] = ymothervertex[13];
2694 xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2695 //////////////////////////////////////////////////////////
2696 coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2697 xmothervertex,ymothervertex);
2698 coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2699 + fgkCoolingTubeRmax));
2700 coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2701 + fgkCoolingTubeRmax));
ca86fdb4 2702 TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
2703// TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
2704// coolingsystemothershape,fSSDAir);
bf210566 2705 /////////////////////////////////////////////////////////////
2706 // SSD Cooling Tube Part
2707 /////////////////////////////////////////////////////////////
2708 TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
2709 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
ca86fdb4 2710 0.5*(fgkSSDCoolingBlockWidth-fgkSSDTolerance));
bf210566 2711 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
ca86fdb4 2712 0.5*(fgkSSDCoolingBlockWidth-fgkSSDTolerance));
bf210566 2713 TGeoVolume* coolingtube[fgkcoolingtubenumber];
2714 coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
2715 fSSDCoolingTubePhynox);
2716 coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
2717 fSSDCoolingTubeWater);
2718 coolingtube[0]->SetLineColor(fColorPhynox);
2719 coolingtube[1]->SetLineColor(fColorWater);
2720 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2721 /////////////////////////////////////////////////////////////
2722 // Adding Cooling block to mother volume
2723 /////////////////////////////////////////////////////////////
2724 for(Int_t i=0; i<kcoolingblocknumber; i++){
9f5fafaf 2725 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
bf210566 2726 coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
2727 coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
d7599219 2728 }
bf210566 2729 /////////////////////////////////////////////////////////////
2730 // Deallocating memory
2731 /////////////////////////////////////////////////////////////
2732 delete coolingblocktransvector;
bf210566 2733 delete localcoolingblockrot;
bf210566 2734 delete localcoolingtubetrans;
2735 delete localcoolingtuberot;
2736 /////////////////////////////////////////////////////////////
2737 // Checking overlaps
2738 /////////////////////////////////////////////////////////////
6727e2db 2739 //coolingsystemother->CheckOverlaps(0.01);
bf210566 2740 /////////////////////////////////////////////////////////////
2741 return coolingsystemother;
d7599219 2742}
2743/////////////////////////////////////////////////////////////////////////////////
bf210566 2744TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2745 /////////////////////////////////////////////////////////////
bf210566 2746 // SSD Flex
44285dfa 2747 /////////////////////////////////////////////////////////////
bf210566 2748 const Int_t kssdflexlayernumber = 2;
2749 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2750 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2751 const Int_t kmothervertexnumber = 17;
2752 Double_t xmothervertex[kmothervertexnumber];
2753 Double_t ymothervertex[kmothervertexnumber];
2754 /////////////////////////////////////////////
2755 // Auxiliary variables for vertex positioning
2756 /////////////////////////////////////////////
2757 const Int_t kssdflexboxnumber = 5;
44285dfa 2758 Double_t ssdflexboxlength[kssdflexboxnumber];
2759 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2760 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2761 * fgkSSDChipSeparationLength
2762 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2763 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2764 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2765 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2766 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2767 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2768 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2769 - ssdflexboxlength[1];
44285dfa 2770 Double_t ssdflexboxwidth[kssdflexboxnumber];
2771 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2772 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2773 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2774 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2775 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2776 ///////////////////////
2777 // Setting the vertices
2778 ///////////////////////
2779 xmothervertex[0] = 0.0;
2780 xmothervertex[1] = xmothervertex[0];
2781 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2782 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2783 + ssdflexboxlength[4];
2784 xmothervertex[4] = xmothervertex[3];
2785 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2786 xmothervertex[6] = xmothervertex[5];
2787 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2788 xmothervertex[8] = xmothervertex[7];
2789 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2790 xmothervertex[10] = xmothervertex[9];
2791 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2792 xmothervertex[12] = xmothervertex[11];
2793 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2794 xmothervertex[14] = xmothervertex[13];
2795 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2796 xmothervertex[16] = xmothervertex[15];
2797 ymothervertex[0] = 0.0;
2798 ymothervertex[1] = fgkSSDFlexWidth[1];
2799 ymothervertex[2] = fgkSSDFlexWidth[0];
2800 ymothervertex[3] = ymothervertex[2];
2801 ymothervertex[4] = ymothervertex[0];
2802 ymothervertex[5] = ymothervertex[4];
2803 ymothervertex[6] = ssdflexboxwidth[2];
2804 ymothervertex[7] = ymothervertex[6];
2805 ymothervertex[8] = ymothervertex[0];
2806 ymothervertex[9] = ymothervertex[8];
2807 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2808 ymothervertex[11] = ymothervertex[10];
2809 ymothervertex[12] = ymothervertex[0];
2810 ymothervertex[13] = ymothervertex[12];
2811 ymothervertex[14] = ymothervertex[7];
2812 ymothervertex[15] = ymothervertex[14];
2813 ymothervertex[16] = ymothervertex[0];
2814 /////////////////////////////////////////////////////////////
2815 // First Mother Volume containing SSDFlex
2816 /////////////////////////////////////////////////////////////
2817 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2818 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2819 ymothervertex);
2820 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2821 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
ca86fdb4 2822 TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2823// TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2824// fSSDAir);
bf210566 2825 /////////////////////////////////////////////////////////////
2826 // SSDFlex Layer Shapes
2827 /////////////////////////////////////////////////////////////
2828 for(Int_t i=0; i<kssdflexlayernumber; i++){
2829 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2830 ymothervertex);
2831 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2832 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2833 }
2834 /////////////////////////////////////
2835 // Setting Layers into Mother Volume
2836 /////////////////////////////////////
2837 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2838 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2839 fSSDKaptonFlexMedium};
2840 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2841 "AlFlexLay2","KaptonFlexLay2"};
2842 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2843 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2844 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2845 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2846 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2847 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2848 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2849 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2850 + fgkSSDFlexHeight[1]));
2851 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2852 }
bf210566 2853 return ssdflexmother;
d7599219 2854}
2855/////////////////////////////////////////////////////////////////////////////////
bf210566 2856TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2857 /////////////////////////////////////////////////////////////
2858 // Method generating SSD End Flex
d7599219 2859 /////////////////////////////////////////
bf210566 2860 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2861 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2862 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2863 * TMath::DegToRad()*ssdflexradiusmax
2864 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 2865 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2866 - 0.1*fgkSSDFlexFullLength;
bf210566 2867 const Int_t knedges = 20;
2868 const Int_t karcnumber = 2;
2869 TVector3* vertexposition[karcnumber*(knedges+1)];
2870 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2871 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2872 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2873 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2874 - 90.0*TMath::DegToRad()};
2875 TVector3* referencetrans[karcnumber];
2876 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2877 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2878 radius[0]);
2879 referencetrans[1] = new TVector3(referencetrans[0]->X()
2880 + fgkSSDFlexLength[2],
2881 - fgkSSDStiffenerHeight);
2882for(Int_t i=0; i<karcnumber; i++){
2883 for(Int_t j=0; j<knedges+1; j++){
2884 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2885 radius[i]*SinD(angle[i]));
2886 angle[i] += deltangle[i]*(1.0-2.0*i);
2887 }
2888 }
2889 ///////////////////////
2890 // Setting the vertices
2891 ///////////////////////
2892 const Int_t kendflexlayernumber = 4;
2893 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2894 TVector3** vertex[kendflexlayernumber];
2895 for(Int_t i=0; i<kendflexlayernumber; i++)
2896 vertex[i] = new TVector3*[kendflexvertexnumber];
2897 TVector3* transvector[kendflexlayernumber+1];
2898 TVector3* deltatransvector = new TVector3();
2899 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2900 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2901 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2902 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2903 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2904 * CosD(fgkSSDFlexAngle),
2905 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2906 * SinD(fgkSSDFlexAngle),0.0);
2907 *transvector[i] = *transvector[i-1]+*deltatransvector;
2908 }
2909 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2910 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2911 for(Int_t i=0; i<karcnumber; i++){
2912 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2913 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2914 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2915 /radius[i];
2916 }
2917 }
2918 for(Int_t i=0; i<kendflexlayernumber; i++){
2919 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2920 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2921 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2922 if(j<(knedges+1)){
2923 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2924 vertexposition[j]->Y()*ratioradius[0][i+1]);
2925 vertex[i][j+2]->RotateZ(referenceangle[0]);
2926 *vertex[i][j+2] += *referencetrans[0];
2927 vertex[i][4*(knedges+1)-j+1] =
2928 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2929 vertexposition[j]->Y()*ratioradius[0][i]);
2930 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2931 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2932 }
2933 else{
2934
2935 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2936 vertexposition[j]->Y()*ratioradius[1][i+1]);
2937 vertex[i][j+2]->RotateZ(referenceangle[1]);
2938 *vertex[i][j+2] += *referencetrans[1];
2939 vertex[i][4*(knedges+1)-j+1] =
2940 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2941 vertexposition[j]->Y()*ratioradius[1][i]);
2942 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2943 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2944 }
2945 }
2946 }
44285dfa 2947 /////////////////////////////////////////////////////////////
bf210566 2948 // First Mother Volume containing SSDEndFlex
2949 /////////////////////////////////////////////////////////////
2950 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2951 Double_t xmothervertex[kendflexvertexnumber];
2952 Double_t ymothervertex[kendflexvertexnumber];
2953 xmothervertex[0] = vertex[0][0]->X();
2954 ymothervertex[0] = vertex[0][0]->Y();
2955 for(Int_t i=1; i<kendflexvertexnumber; i++){
2956 if(i<2*(knedges+1)+2){
2957 xmothervertex[i] = vertex[3][i]->X();
2958 ymothervertex[i] = vertex[3][i]->Y();
2959 }
2960 else{
2961 xmothervertex[i] = vertex[0][i]->X();
2962 ymothervertex[i] = vertex[0][i]->Y();
2963 }
2964 }
2965 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2966 xmothervertex,ymothervertex);
2967 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2968 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
0fb26117 2969// TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2970// ssdendflexmothershape,fSSDAir);
2971 TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
bf210566 2972 //////////////////////////////////////
2973 // End Flex TGeoXtru Layer Definition
2974 //////////////////////////////////////
2975 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2976 TGeoVolume* ssdendflex[kendflexlayernumber];
2977 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2978 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2979 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2980 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2981 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2982 fSSDKaptonFlexMedium};
2983 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2984 "AlEndFlexLay2","KaptonEndFlexLay2"};
2985 for(Int_t i=0; i<kendflexlayernumber; i++){
2986 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2987 xvertex[i][j] = vertex[i][j]->X();
2988 yvertex[i][j] = vertex[i][j]->Y();
2989 }
2990 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2991 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2992 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2993 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2994 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2995 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2996 ssdendflexmother->AddNode(ssdendflex[i],1);
2997 }
44285dfa 2998 /////////////////////////////////////////////////////////////
bf210566 2999 // Deallocating memory
44285dfa 3000 /////////////////////////////////////////////////////////////
bf210566 3001 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
3002 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
3003 for(Int_t i=0; i<kendflexlayernumber; i++){
3004 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
3005 delete [] vertex[i];
3006 }
3007 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
3008 delete deltatransvector;
44285dfa 3009 /////////////////////////////////////////////////////////////
6727e2db 3010 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 3011 return ssdendflexmother;
d7599219 3012}
9b0c60ab 3013///////////////////////////////////////////////////////////////////////////////
bf210566 3014TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 3015 /////////////////////////////////////////////////////////////
9b0c60ab 3016 // Method generating the Mounting Block
bf210566 3017 /////////////////////////////////////////////////////////////
9b0c60ab 3018 const Int_t kvertexnumber = 8;
3019 Double_t xvertex[kvertexnumber];
3020 Double_t yvertex[kvertexnumber];
3021 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3022 xvertex[1] = xvertex[0];
3023 xvertex[2] = -xvertex[0];
3024 xvertex[3] = xvertex[2];
3025 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
3026 - fgkSSDMountingBlockLength[2]);
3027 xvertex[5] = xvertex[4];
3028 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
3029 - 0.5*fgkSSDMountingBlockScrewHoleEdge
3030 - fgkSSDMountingBlockScrewHoleRadius[0];
3031 xvertex[7] = xvertex[6];
3032 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 3033 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 3034 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
3035 yvertex[2] = yvertex[1];
3036 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
3037 yvertex[4] = yvertex[3];
3038 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
3039 - fgkSSDMountingBlockHeight[0];
3040 yvertex[6] = yvertex[5];
3041 yvertex[7] = yvertex[0];
3042 ///////////////////////////////////////////////////////////////////////
3043 // TGeoXTru Volume definition for Mounting Block Part
3044 ///////////////////////////////////////////////////////////////////////
3045 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
3046 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
3047 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3048 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 3049 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 3050 ssdmountingblockshape,
3051 fSSDMountingBlockMedium);
3052 ssdmountingblock->SetLineColor(fColorG10);
3053 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
3054 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
3055 TGeoRotation* mountingblockrot = new TGeoRotation();
3056 mountingblockrot->SetAngles(90.,180.,-90.);
3057 mountingblockcombitrans->SetRotation(*mountingblockrot);
3058 /////////////////////////////////////////////////////////////
3059 // Generating the Mounting Block Screw Vertices
3060 /////////////////////////////////////////////////////////////
3061 const Int_t kscrewvertexnumber = 15;
3062 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
3063 - fgkSSDMountingBlockScrewHoleEdge)
3064 / fgkSSDMountingBlockScrewHoleRadius[0])
3065 * TMath::RadToDeg();
3066 Double_t phi0 = 90.+alpha;
3067 Double_t phi = 270.-2*alpha;
3068 Double_t deltaphi = phi/kscrewvertexnumber;
3069 TVector3* screwvertex[kscrewvertexnumber+1];
3070 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
3071 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
3072 *CosD(phi0+i*deltaphi),
3073 fgkSSDMountingBlockScrewHoleRadius[0]
3074 *SinD(phi0+i*deltaphi));
3075 Double_t xscrewvertex[kscrewvertexnumber+6];
3076 Double_t yscrewvertex[kscrewvertexnumber+6];
3077 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
3078 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
3079 - fgkSSDMountingBlockScrewHoleEdge);
3080 xscrewvertex[1] = xscrewvertex[0];
3081 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3082 xscrewvertex[2] = screwvertex[0]->X();
3083 yscrewvertex[2] = yscrewvertex[1];
3084 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
3085 xscrewvertex[i+3] = screwvertex[i]->X();
3086 yscrewvertex[i+3] = screwvertex[i]->Y();
3087 }
3088 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3089 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
3090 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
3091 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
3092 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
3093 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
3094 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
3095 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
3096 + fgkSSDMountingBlockHeight[2]);
3097 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
3098 ssdmountingblockscrewshape,
3099 fSSDMountingBlockMedium);
3100 ssdmountingblockscrew->SetLineColor(fColorG10);
3101 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
3102 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
3103 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3104 - yscrewvertex[1],
3105 0.5*fgkSSDMountingBlockHeight[0]
3106 - fgkSSDMountingBlockHeight[2]
3107 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3108 + fgkSSDMountingBlockHeight[2]
3109 - yvertex[0]));
3110 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3111 -0.5*fgkSSDMountingBlockScrewHoleEdge,
3112 yscrewvertex[1]
3113 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3114 +fgkSSDMountingBlockHeight[2]
3115 -yvertex[0]));
3116 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3117 yscrewvertex[1],
3118 - 0.5*fgkSSDMountingBlockHeight[0]
3119 + fgkSSDMountingBlockHeight[2]
3120 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3121 + fgkSSDMountingBlockHeight[2]
3122 - yvertex[0]));
3123 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3124 yscrewvertex[1],
3125 - yscrewvertex[1]
3126 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3127 + fgkSSDMountingBlockHeight[2]
3128 - yvertex[0]));
3129 TGeoRotation* ssdmountingblockscrewrot[4];
3130 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3131 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3132 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3133 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3134 for(Int_t i=1; i<4; i++)
3135 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3136 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3137 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3138 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3139 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3140 + xvertex[0],yscrewvertex[1]
3141 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3142 + fgkSSDMountingBlockHeight[2]
3143 - yvertex[0]),0.);
3144 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3145 for(Int_t i=0; i<4; i++){
3146 ssdmountingblockscrewmatrix[i] =
3147 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3148 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3149 }
3150 ///////////////////////////////////////////////////////////////////////
3151 // TGeoXtru for Mother Volume
3152 ///////////////////////////////////////////////////////////////////////
3153 const Int_t kvertexmothernumber = 12;
3154 Double_t xmothervertex[kvertexmothernumber];
3155 Double_t ymothervertex[kvertexmothernumber];
3156 for(Int_t i=0; i<6; i++){
3157 xmothervertex[i] = xvertex[i];
3158 ymothervertex[i] = yvertex[i];
3159 }
3160 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3161 ymothervertex[6] = ymothervertex[5];
3162 xmothervertex[7] = xmothervertex[6];
3163 ymothervertex[7] = ymothervertex[4];
3164 xmothervertex[8] = xmothervertex[7]
3165 + 0.5*(fgkSSDMountingBlockLength[1]
3166 - fgkSSDMountingBlockLength[2]);
3167 ymothervertex[8] = ymothervertex[4];
3168 xmothervertex[9] = xmothervertex[8];
3169 ymothervertex[9] = ymothervertex[2];
3170 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3171 ymothervertex[10] = ymothervertex[1];
3172 xmothervertex[11] = xmothervertex[10];
3173 ymothervertex[11] = ymothervertex[0];
3174 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3175 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3176 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3177 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3178 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3179 ssdmountingblockmothershape,
3180 fSSDAir);
3181 /////////////////////////////////////////////////////////////
3182 // Placing the Volumes into Mother Volume
3183 /////////////////////////////////////////////////////////////
3184 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3185 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3186 for(Int_t i=0; i<4; i++)
3187 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3188 ssdmountingblockscrewmatrix[i]);
3189 /////////////////////////////////////////////////////////////
3190 // Deallocating memory
3191 /////////////////////////////////////////////////////////////
3192 delete mountingblockrot;
3193 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3194 delete ssdmountingblockglobalrot;
3195 delete ssdmountingblockglobaltrans;
3196 /////////////////////////////////////////////////////////////
3197 return ssdmountingblockmother;
3198}
3199///////////////////////////////////////////////////////////////////////////////
3200 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3201 /////////////////////////////////////////////////////////////
3202 // Method generating the Mounting Block Clip
3203 /////////////////////////////////////////////////////////////
3204 const Int_t kmothervertexnumber = 10;
3205 Double_t xmothervertex[kmothervertexnumber];
3206 Double_t ymothervertex[kmothervertexnumber];
3207 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3208 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3209 xmothervertex[1] = xmothervertex[0];
3210 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3211 - fgkMountingBlockClibScrewRadius);
3212 xmothervertex[3] = xmothervertex[2];
3213 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3214 xmothervertex[5] = xmothervertex[4];
3215 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3216 xmothervertex[7] = xmothervertex[6];
3217 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3218 xmothervertex[9] = xmothervertex[8];
3219 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 3220 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 3221 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3222 ymothervertex[2] = ymothervertex[1];
3223 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3224 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3225 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3226 ymothervertex[4] = ymothervertex[3];
3227 ymothervertex[5] = ymothervertex[2];
3228 ymothervertex[6] = ymothervertex[5];
3229 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3230 ymothervertex[8] = ymothervertex[7];
3231 ymothervertex[9] = ymothervertex[0];
3232 ///////////////////////////////////////////////////////////////////////
3233 // TGeoXTru Volume definition for Mounting Block Clip Part
3234 ///////////////////////////////////////////////////////////////////////
3235 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3236 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3237 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3238 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3239 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3240 ssdmountingblockclipshape,fSSDAir);
3241 ssdmountingblockclip->SetLineColor(4);
3242 ///////////////////////////////////////////////////////////////////////
3243 // TGeoXTru Volume definition for Clip
3244 ///////////////////////////////////////////////////////////////////////
3245 const Int_t kclipvertexnumber = 6;
3246 Double_t xclipvertex[kclipvertexnumber];
3247 Double_t yclipvertex[kclipvertexnumber];
3248 xclipvertex[0] = xmothervertex[0];
3249 xclipvertex[1] = xclipvertex[0];
3250 xclipvertex[2] = xmothervertex[6];
3251 xclipvertex[3] = xclipvertex[2];
3252 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3253 xclipvertex[5] = xclipvertex[4];
3254 yclipvertex[0] = ymothervertex[0];
3255 yclipvertex[1] = ymothervertex[1];
3256 yclipvertex[2] = yclipvertex[1];
3257 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3258 yclipvertex[4] = yclipvertex[3];
3259 yclipvertex[5] = yclipvertex[0];
3260 TGeoXtru* clipshape = new TGeoXtru(2);
3261 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3262 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3263 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3264 + fgkMountingBlockClibWidth);
3265 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3266 clip->SetLineColor(18);
3267 ///////////////////////////////////////////////////////////////////////
3268 // Ladder Support Piece
3269 ///////////////////////////////////////////////////////////////////////
3270 const Int_t ksupportvertexnumber = 4;
3271 Double_t xsupportvertex[ksupportvertexnumber];
3272 Double_t ysupportvertex[ksupportvertexnumber];
3273 xsupportvertex[0] = xclipvertex[5];
3274 xsupportvertex[1] = xsupportvertex[0];
3275 xsupportvertex[2] = xmothervertex[9];
3276 xsupportvertex[3] = xsupportvertex[2];
3277 ysupportvertex[0] = yclipvertex[0];
3278 ysupportvertex[1] = yclipvertex[3];
3279 ysupportvertex[2] = ysupportvertex[1];
3280 ysupportvertex[3] = ysupportvertex[0];
3281 TGeoXtru* supportshape = new TGeoXtru(2);
3282 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3283 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3284 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3285 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3286 support->SetLineColor(9);
3287 ///////////////////////////////////////////////////////////////////////
3288 // TGeoXTru Volume definition for Screw
3289 ///////////////////////////////////////////////////////////////////////
3290 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3291 0.5*fgkMountingBlockClibScrewRadius};
3292 Int_t edgesnumber[2] = {50,6};
3293 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3294 +0.5*(ymothervertex[3]-ymothervertex[2])};
851c0ce3 3295 TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
9b0c60ab 3296 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3297 clipscrew->SetLineColor(12);
3298 TGeoRotation* screwrot = new TGeoRotation();
3299 screwrot->SetAngles(0.,90.,0.);
3300 TGeoTranslation* screwtrans = new TGeoTranslation();
3301 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3302 0.5*(ymothervertex[3]+ymothervertex[2]),
3303 0.5*fgkSSDMountingBlockWidth+
3304 -0.5*fgkMountingBlockSupportWidth[0]);
3305 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3306 ///////////////////////////////////////////////////////////////////////
3307 // Placing the Volumes
3308 ///////////////////////////////////////////////////////////////////////
3309 ssdmountingblockclip->AddNode(clip,1);
3310 ssdmountingblockclip->AddNode(support,1);
3311 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3312 /////////////////////////////////////////////////////////////
3313 // Deallocating memory
3314 /////////////////////////////////////////////////////////////
3315 delete screwtrans;
3316 delete screwrot;
3317 /////////////////////////////////////////////////////////////
3318 return ssdmountingblockclip;
d7599219 3319}
bf210566 3320///////////////////////////////////////////////////////////////////////////////
3321TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
44285dfa 3322 /////////////////////////////////////////////////////////////
bf210566 3323 // Method generating the Cooling Tube
44285dfa 3324 /////////////////////////////////////////////////////////////
bf210566 3325 TGeoTube** coolingtubeshape[fgkcoolingtubenumber];
3326 for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtubeshape[i] =
3327 new TGeoTube*[2];
9b0c60ab 3328 // Ladder Cooling Tubes
bf210566 3329 coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3330 0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
0fb26117 3331 - 2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
3332 -0.5*fgkSSDTolerance);
bf210566 3333 coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3334 coolingtubeshape[0][0]->GetDz());
3335 coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3336 0.5*(fgkSSDModuleStiffenerPosition[1]
0fb26117 3337 - fgkSSDSensorOverlap-fgkSSDTolerance));
bf210566 3338 coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3339 coolingtubeshape[1][0]->GetDz());
3340 coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
0fb26117 3341 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDTolerance));
bf210566 3342 coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
0fb26117 3343 coolingtubeshape[2][0]->GetDz()-0.5*fgkSSDTolerance);
9b0c60ab 3344 // End Ladder Cooling Tubes
3345 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3346 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
ca86fdb4 3347 endladdercoolingtubeshape[i] = new TGeoTube*[2];
9b0c60ab 3348 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3349 0.50 * (fgkEndLadderMountingBlockPosition[0]
ca86fdb4 3350 - fgkendladdercoolingsupportdistance[0]-fgkSSDTolerance));
9b0c60ab 3351 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3352 endladdercoolingtubeshape[0][0]->GetDz());
3353 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3354 0.50 * (fgkendladdercoolingsupportdistance[0]
3355 + fgkendladdercoolingsupportdistance[1]
ca86fdb4 3356 - fgkCoolingTubeSupportWidth-fgkSSDTolerance));
9b0c60ab 3357 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
0fb26117 3358 endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
9b0c60ab 3359 endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3360 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
3361 - fgkEndLadderMountingBlockPosition[0]
3362 - fgkendladdercoolingsupportdistance[1]
ca86fdb4 3363 - fgkCoolingTubeSupportWidth-fgkSSDTolerance));
9b0c60ab 3364 endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
0fb26117 3365 endladdercoolingtubeshape[2][0]->GetDz()-0.5*fgkSSDTolerance);
9b0c60ab 3366 endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3367 0.50 * (fgkMountingBlockToSensorSupport
3368 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
3369 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
3370 + fgkSSDSensorOverlap
3371 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
3372 - fgkendladdercoolingsupportdistance[2]
3373 - fgkEndLadderMountingBlockPosition[1]
ca86fdb4 3374 - fgkCoolingTubeSupportWidth-fgkSSDTolerance));
9b0c60ab 3375 endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
0fb26117 3376 endladdercoolingtubeshape[3][0]->GetDz()-0.5*fgkSSDTolerance);
9b0c60ab 3377 endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
ca86fdb4 3378 0.50 * (fgkendladdercoolingsupportdistance[2]-fgkSSDTolerance));
9b0c60ab 3379 endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
0fb26117 3380 endladdercoolingtubeshape[4][0]->GetDz()-0.5*fgkSSDTolerance);
9b0c60ab 3381 // Ladder Cooling Tubes
bf210566 3382 TGeoVolume** coolingtube[fgkcoolingtubenumber];
3383 for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtube[i] =
3384 new TGeoVolume*[2];
3385 coolingtube[0][0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0][0],
3386 fSSDCoolingTubePhynox);
3387 coolingtube[0][1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[0][1],
3388 fSSDCoolingTubeWater);
3389 coolingtube[1][0] = new TGeoVolume("OuterCoolingTube2",coolingtubeshape[1][0],
3390 fSSDCoolingTubePhynox);
3391 coolingtube[1][1] = new TGeoVolume("InnerCoolingTube2",coolingtubeshape[1][1],
3392 fSSDCoolingTubeWater);
3393 coolingtube[2][0] = new TGeoVolume("OuterCoolingTube3",coolingtubeshape[2][0],
3394 fSSDCoolingTubePhynox);
3395 coolingtube[2][1] = new TGeoVolume("InnerCoolingTube3",coolingtubeshape[2][1],
3396 fSSDCoolingTubeWater);
3397 for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3398 coolingtube[i][0]->SetLineColor(fColorPhynox);
3399 coolingtube[i][1]->SetLineColor(fColorWater);
3400 }
9b0c60ab 3401 // End Ladder Cooling Tubes
3402 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3403 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3404 endladdercoolingtube[i] = new TGeoVolume*[2];
3405 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3406 endladdercoolingtubeshape[0][0],
3407 fSSDCoolingTubePhynox);
3408 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3409 endladdercoolingtubeshape[0][1],
3410 fSSDCoolingTubeWater);
3411 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3412 endladdercoolingtubeshape[1][0],
3413 fSSDCoolingTubePhynox);
3414 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3415 endladdercoolingtubeshape[1][1],
3416 fSSDCoolingTubeWater);
3417 endladdercoolingtube[2][0] = new TGeoVolume("OuterEndLadderCoolingTube3",
3418 endladdercoolingtubeshape[2][0],
3419 fSSDCoolingTubePhynox);
3420 endladdercoolingtube[2][1] = new TGeoVolume("InnerEndlLadderCoolingTube3",
3421 endladdercoolingtubeshape[2][1],
3422 fSSDCoolingTubeWater);
3423 endladdercoolingtube[3][0] = new TGeoVolume("OuterEndLadderCoolingTube4",
3424 endladdercoolingtubeshape[3][0],
3425 fSSDCoolingTubePhynox);
3426 endladdercoolingtube[3][1] = new TGeoVolume("InnerEndlLadderCoolingTube4",
3427 endladdercoolingtubeshape[3][1],
3428 fSSDCoolingTubeWater);
3429 endladdercoolingtube[4][0] = new TGeoVolume("OuterEndLadderCoolingTube5",
3430 endladdercoolingtubeshape[4][0],
3431 fSSDCoolingTubePhynox);
3432 endladdercoolingtube[4][1] = new TGeoVolume("InnerEndlLadderCoolingTube5",
3433 endladdercoolingtubeshape[4][1],
3434 fSSDCoolingTubeWater);
3435 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
ca86fdb4 3436 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3437 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
9b0c60ab 3438 }
0fb26117 3439
bf210566 3440 /////////////////////////////////////////////////////////////
3441 // Virtual Volume containing Cooling Tubes
3442 /////////////////////////////////////////////////////////////
9b0c60ab 3443 // Ladder Cooling Tubes
bf210566 3444 TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber];
3445 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
3446 virtualcoolingtubeshape[i] = new TGeoTube(coolingtubeshape[i][1]->GetRmin(),
3447 coolingtubeshape[i][0]->GetRmax(),
3448 coolingtubeshape[i][0]->GetDz());
3449 TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber];
3450 virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0],
3451 fSSDAir);
3452 virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1],
3453 fSSDAir);
3454 virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2],
3455 fSSDAir);
9b0c60ab 3456 // End Ladder Cooling Tubes
3457 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3458 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3459 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3460 endladdercoolingtubeshape[i][0]->GetRmax(),
3461 endladdercoolingtubeshape[i][0]->GetDz());
3462 TGeoVolume* endladdervirtualcoolingtube[fgkendladdercoolingtubenumber];
3463 endladdervirtualcoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3464 endladdervirtualcoolingtubeshape[0],
3465 fSSDAir);
3466 endladdervirtualcoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3467 endladdervirtualcoolingtubeshape[1],
3468 fSSDAir);
3469 endladdervirtualcoolingtube[2] = new TGeoVolume("EndLadderCoolingTube3",
3470 endladdervirtualcoolingtubeshape[2],
3471 fSSDAir);
3472 endladdervirtualcoolingtube[3] = new TGeoVolume("EndLadderCoolingTube4",
3473 endladdervirtualcoolingtubeshape[3],
3474 fSSDAir);
3475 endladdervirtualcoolingtube[4] = new TGeoVolume("EndLadderCoolingTube5",
3476 endladdervirtualcoolingtubeshape[4],
3477 fSSDAir);
bf210566 3478 TList* coolingtubelist = new TList();
3479 for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3480 virtualcoolingtube[i]->AddNode(coolingtube[i][0],1);
3481 virtualcoolingtube[i]->AddNode(coolingtube[i][1],1);
3482 coolingtubelist->Add(virtualcoolingtube[i]);
d7599219 3483 }
9b0c60ab 3484 endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3485 endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3486 coolingtubelist->Add(endladdervirtualcoolingtube[0]);
3487 endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3488 endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3489 coolingtubelist->Add(endladdervirtualcoolingtube[1]);
3490 endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][0],1);
3491 endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][1],1);
3492 coolingtubelist->Add(endladdervirtualcoolingtube[2]);
3493 endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][0],1);
3494 endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][1],1);
3495 coolingtubelist->Add(endladdervirtualcoolingtube[3]);
3496 endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][0],1);
3497 endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][1],1);
3498 coolingtubelist->Add(endladdervirtualcoolingtube[4]);
bf210566 3499 return coolingtubelist;
d7599219 3500}
bf210566 3501///////////////////////////////////////////////////////////////////////////////
3502TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3503 /////////////////////////////////////////////////////////////
bf210566 3504 // Method generating SSD Cooling Block
44285dfa 3505 /////////////////////////////////////////////////////////////
bf210566 3506 const Int_t kvertexnumber = 8;
3507 ///////////////////////////////////////
3508 // Vertex Positioning for TGeoXTru
3509 ///////////////////////////////////////
3510 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3511 vertexposition[0] = new TVector3(0.0,0.0);
3512 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3513 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3514 vertexposition[1]->Y());
3515 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3516 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3517 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3518 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3519 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3520 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3521 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3522 - fgkSSDCoolingBlockHoleLength[0]
3523 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3524 fgkSSDCoolingBlockHeight[0]
3525 - fgkSSDCoolingBlockHoleRadius[1],
3526 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3527 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3528 - fgkSSDCoolingBlockHoleLength[0]),
3529 vertexposition[6]->Y());
3530 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3531 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3532 Double_t phi = 180.-alpha;
3533 Double_t psi = 180.+2.*alpha;
3534 Double_t deltapsi = psi/nedges;
3535 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3536 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3537 fgkSSDCoolingBlockHoleCenter);
3538 for(Int_t i=0; i<nedges+1; i++){
3539 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3540 radius*SinD(phi+i*deltapsi));
3541 *vertexposition[kvertexnumber+i] += (*transvector);
3542 }
3543 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3544 for(Int_t i=0; i<kvertexnumber; i++)
3545 vertexposition[kvertexnumber+nedges+1+i] =
3546 GetReflection(vertexposition[kvertexnumber-1-i],param);
3547 ///////////////////////////////////////////////////////////////////////
3548 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3549 ///////////////////////////////////////////////////////////////////////
3550 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3551 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3552 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3553 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3554 xvertexpoints[i] = vertexposition[i]->X();
3555 yvertexpoints[i] = vertexposition[i]->Y();
3556 }
3557 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3558 yvertexpoints);
3559 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3560 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3561 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3562 ssdcoolingblockshape,
3563 fSSDAlCoolBlockMedium);
3564 ssdcoolingblock->SetLineColor(fColorAl);
3565 /////////////////////////////////////////////////////////////
3566 // Deallocating memory
3567 /////////////////////////////////////////////////////////////
3568 delete [] vertexposition;
3569 delete xvertexpoints;
3570 delete yvertexpoints;
3571 /////////////////////////////////////////////////////////////
3572 return ssdcoolingblock;
3573}
3574/////////////////////////////////////////////////////////////////////////////////
3575TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
d7599219 3576 ///////////////////////////////////////////////////////
bf210566 3577 const Int_t kssdchipcablesnumber = 2;
3578 const Int_t kssdchipcableslaynumber = 2;
3579 const Int_t kvertexnumber = 4*(nedges+1)+4;
3580 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3581 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3582 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
3583 - fgkSSDChipCablesHeight[0]
3584 - fgkSSDChipCablesHeight[1]);
3585 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3586 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3587 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3588 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3589 - ssdchipcablesradius[0]
3590 - fgkSSDChipCablesWidth[1]
3591 - fgkSSDChipCablesWidth[2]);
3592 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3593 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3594 + fgkSSDChipCablesHeight[1]
3595 + fgkSSDSensorHeight);
d7599219 3596 ///////////////////////////////////////////////////////
bf210566 3597 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3598 ///////////////////////////////////////////////////////
3599 TVector3** vertexposition[kssdchipcableslaynumber];
3600 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3601 new TVector3*[4*(nedges+1)+4];
3602 Double_t ratio[4];
3603 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3604 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3605 / ssdchipcablesradius[0];
3606 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3607 / ssdchipcablesradius[0];
3608 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3609 + fgkSSDChipCablesHeight[1])
3610 / ssdchipcablesradius[0];
3611 Double_t phi = 180.;
3612 Double_t deltaphi = 180./nedges;
3613 Double_t angle = 0.0;
3614 Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3615 Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3616 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3617 xvertexpoints[i] = new Double_t[kvertexnumber];
3618 yvertexpoints[i] = new Double_t[kvertexnumber];
3619 }
3620 TVector3* vertex = new TVector3();
3621 TVector3* transvector[kssdchipcableslaynumber];
3622 transvector[0] = new TVector3(fgkSSDChipWidth,
3623 SSDChipCablesHeigth-ssdchipcablesradius[0]);
3624 transvector[1] = new TVector3();
3625 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
3626 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
3627 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
3628 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3629 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3630 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3631 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3632 transvector[1]->SetY(ssdchipcablesradius[0]
3633 + fgkSSDChipCablesHeight[0]
3634 + fgkSSDChipCablesHeight[1]);
3635 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3636 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
3637 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
3638 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
3639 - i*fgkSSDChipCablesHeight[0]);
3640 vertexposition[i][2*(nedges+1)+2] =
3641 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3642 + fgkSSDChipCablesWidth[1]
3643 + fgkSSDChipCablesWidth[2],
3644 ((1.-i)*fgkSSDChipCablesHeight[i]
3645 + fgkSSDChipCablesHeight[1]));
3646 vertexposition[i][2*(nedges+1)+3] =
3647 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3648 vertexposition[i][2*(nedges+1)+2]->Y()
3649 - fgkSSDChipCablesHeight[i]);
3650 for(Int_t j=0; j<nedges+1; j++){
3651 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3652 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3653 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3654 vertexposition[0][(nedges+1)*i+j+2] =
3655 new TVector3(*vertex+*transvector[i]);
3656 vertexposition[1][(nedges+1)*i+j+2] =
3657 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3658 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3659 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3660 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3661 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3662 new TVector3(vertex->X()*ratio[2*i+1]
3663 + transvector[i]->X(),
3664 vertex->Y()*ratio[2*i+1]
3665 + transvector[i]->Y());
3666 }
3667 }
3668 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3669 for(Int_t j=0; j<kvertexnumber; j++){
3670 xvertexpoints[i][j] = vertexposition[i][j]->X();
3671 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3672 }
3673 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3674 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3675 xvertexpoints[i],yvertexpoints[i]);
3676 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3677 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3678 ssdchipcable[kssdchipcablesnumber*k+i] =
3679 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3680 ssdchipcableshape[kssdchipcablesnumber*k+i],
3681 (kssdchipcablesnumber*k+i)%2==0?
3682 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3683 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3684 }
3685 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3686 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3687 }
44285dfa 3688 /////////////////////////////////////////////////////////////
bf210566 3689 // Mother Volume definition
3690 /////////////////////////////////////////////////////////////
3691 Double_t ssdchipseparation = fgkSSDSensorLength
3692 - 2.*fgkSSDModuleStiffenerPosition[1]
3693 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3694 - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
3695 Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth};
3696 Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0]
3697 +fgkSSDChipCablesWidth[1]
3698 +fgkSSDChipCablesWidth[2]);
3699 Double_t dy = fgkSSDChipCablesLength[1];
3700 Double_t dz = SSDChipCablesHeigth;
851c0ce3 3701 new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
ca86fdb4 3702 TGeoVolumeAssembly* ssdchipcablesmother = new TGeoVolumeAssembly("SSDChipCablesMother");
3703// TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother",
3704// ssdchipcablesmotherbox,fSSDAir);
bf210566 3705 /////////////////////////////////////////////////////////////
3706 // Rotation and Translation Definition for positioning
3707 /////////////////////////////////////////////////////////////
3708 TGeoRotation* ssdchipcablesrot[5];
3709 ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
3710 ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
3711 ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
3712 ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
3713 ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
3714 TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,
3715 0.,0.,ssdchipcablesrot[2]);
3716 ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]);
3717 ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]);
3718 ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans);
3719 ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans);
3720 /////////////////////////////////////////////////////////////
3721 // Deallocating memory
3722 /////////////////////////////////////////////////////////////
3723 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3724 delete [] xvertexpoints[i];
3725 delete [] yvertexpoints[i];
3726 }
3727 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3728 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3729 delete vertex;
3730 delete ssdchipcablesrot[0];
3731 delete ssdchipcablesrot[1];
3732 delete ssdchipcablesrot[3];
3733 /////////////////////////////////////////////////////////////
3734 return ssdchipcablesmother;
d7599219 3735}
bf210566 3736///////////////////////////////////////////////////////////////////////////////
3737TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
3738 /////////////////////////////////////////////////////////////
3739 // SSD Chip Assembly
3740 /////////////////////////////////////////////////////////////
3741 TGeoVolume* ssdchipassembly = GetSSDChips();
3742 TList* ssdchipsystemlist = new TList();
e21cdd03 3743// const Int_t knedges = 20;
3744 const Int_t knedges = 5;
bf210566 3745 const Int_t kchipsystemnumber = 2;
5bf92139 3746
ca86fdb4 3747 TGeoVolumeAssembly* chipsystemother[kchipsystemnumber];
bf210566 3748 const char* chipsytemothername[kchipsystemnumber] =
3749 {"SSDChipSytemother1","SSDChipSytemother2"};
3750 for(Int_t i=0; i<kchipsystemnumber; i++){
ca86fdb4 3751 chipsystemother[i] = new TGeoVolumeAssembly(chipsytemothername[i]);
bf210566 3752 }
44285dfa 3753 /////////////////////////////////////////////////////////////
bf210566 3754 // SSD Chip Cables
3755 /////////////////////////////////////////////////////////////
3756 TGeoVolume* ssdchipcables[kchipsystemnumber];
3757 TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
3758 TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
3759 TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
3760 //////////////////
3761 for(Int_t i=0; i<kchipsystemnumber; i++){
3762 ssdchipcables[i] =
3763 GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
3764 ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
3765 ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
3766 ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
3767 }
3768 for(Int_t i=0; i<kchipsystemnumber; i++){
3769 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3770 ssdchipcablestrans[i][j] = new TGeoTranslation();
3771 ssdchipcablesrot[i][j] = new TGeoRotation();
3772 ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
3773 ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
3774 ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
3775 + fgkSSDChipSeparationLength),
3776 0.5*fgkSSDChipWidth,
3777 - 0.5*fgkSSDChipHeight
3778 - fgkSSDChipCablesHeight[i+2]);
3779 ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
3780 ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
3781 chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
bf210566 3782 }
3783 chipsystemother[i]->AddNode(ssdchipassembly,i+1);
e21cdd03 3784 ssdchipsystemlist->Add(chipsystemother[i]);
bf210566 3785 }
3786 /////////////////////////////////////////////////////////////
3787 // Deallocating memory
3788 /////////////////////////////////////////////////////////////
3789 for(Int_t i=0; i<kchipsystemnumber; i++){
3790 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3791 delete ssdchipcablesrot[i][j];
3792 delete ssdchipcablestrans[i][j];
3793 }
3e008bd7 3794 delete [] ssdchipcablesrot[i];
3795 delete [] ssdchipcablestrans[i];
bf210566 3796 }
3797 /////////////////////////////////////////////////////////////
3798 return ssdchipsystemlist;
d7599219 3799}
5bf92139 3800
3801//_____________________________________________________________________________
bf210566 3802TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
44285dfa 3803 /////////////////////////////////////////////////////////////
bf210566 3804 // SSD Chip Assembly Generation
3805 /////////////////////////////////////////////////////////////
3806 const Int_t kssdchiprownumber = 2;
3807 TGeoBBox* ssdchipcompshape[2];
3808 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3809 0.5*fgkSSDChipLength,
3810 0.5*fgkSSDChipWidth,
3811 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3812 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3813 0.5*fgkSSDChipLength,
3814 0.5*fgkSSDChipWidth,
3815 0.5*fgkSSDChipGlueHeight);
3816 TGeoVolume* ssdchipcomp[2];
3817 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3818 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3819 fSSDChipGlueMedium);
3820 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3821 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3822 TGeoTranslation* ssdchipcomptrans[2];
3823 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3824 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3825 /////////////////////////////////////////////////////////////
3826 // Virtual Volume containing SSDChip
3827 /////////////////////////////////////////////////////////////
3828 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3829 0.5*fgkSSDChipWidth,
3830 0.5*fgkSSDChipHeight);
e21cdd03 3831 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
bf210566 3832 /////////////////////////////////////////////////////////////
3833 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3834 Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
3835 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3836 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3837 - 0.5*fgkSSDChipWidth)};
3838 /////////////////////////////////////////////////////////////
3839 // Virtual Volume containing SSDChipAssembly
3840 /////////////////////////////////////////////////////////////
3841 TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
3842 const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
3843 Double_t xmothervertex[kssdmothervertexnumber];
3844 Double_t ymothervertex[kssdmothervertexnumber];
3845 ///////////////////////
3846 // Setting the vertices
3847 ///////////////////////
3848 xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
3849 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
3850 - ymothervertex[0];
3851 xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
3852 ymothervertex[2] = ymothervertex[1];
3853 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
3854 xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
3855 ymothervertex[4] = ymothervertex[0];
3856 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
3857 xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
3858 + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
3859 ymothervertex[6] = ymothervertex[5];
3860 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
3861 - fgkSSDChipWidth;
3862 xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3863 ymothervertex[8] = ymothervertex[7];
3864 xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3865 ymothervertex[9] = ymothervertex[6];
3866 xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
3867 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
3868 //////////////////////////////////////////////////////////
3869 ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
3870 xmothervertex,ymothervertex);
3871 ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
3872 ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
9f5fafaf 3873// TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
3874// ssdchipmothershape,fSSDAir);
3875 TGeoVolumeAssembly* ssdchipmother = new TGeoVolumeAssembly("SSDChipContainer");
bf210566 3876 /////////////////////////////////////////////////////////////
3877 for(Int_t i=0; i<kssdchiprownumber; i++)
3878 for(Int_t j=0; j<fgkSSDChipNumber; j++)
3879 ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
3880 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
3881 return ssdchipmother;
d7599219 3882}
bf210566 3883/////////////////////////////////////////////////////////////////////////////////
3884TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3885 /////////////////////////////////////////////////////////////
bf210566 3886 // Method returning a List containing pointers to Ladder Cable Volumes
44285dfa 3887 /////////////////////////////////////////////////////////////
bf210566 3888 const Int_t kladdercablesegmentnumber = 2;
3889 /////////////////////////////////////////
3890 // LadderSegmentBBox Volume
3891 /////////////////////////////////////////
3892 TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
3893 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3894 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3895 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3896 new TGeoBBox(laddercablesegmentbboxshapename[i],
3897 0.5*fgkSSDFlexWidth[0],
3898 0.5*fgkSSDLadderCableWidth,
3899 0.5*fgkSSDFlexHeight[i]);
3900 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3901 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3902 TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3903 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3904 laddercablesegmentbbox[i] =
3905 new TGeoVolume(laddercablesegmentbboxname[i],
3906 laddercablesegmentbboxshape[i],
3907 (i==0?fSSDAlTraceLadderCableMedium:
3908 fSSDKaptonLadderCableMedium));
3909 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3910 fColorPolyhamide);
3911 }
3912 TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
3913 laddercablesegmentbboxtrans[0] =
3914 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3915 0.5*fgkSSDFlexWidth[0],
3916 0.5*fgkSSDLadderCableWidth,
3917 0.5*fgkSSDFlexHeight[0]);
3918 laddercablesegmentbboxtrans[1] =
3919 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3920 0.5*fgkSSDFlexWidth[0],
3921 0.5*fgkSSDLadderCableWidth,
3922 fgkSSDFlexHeight[0]
3923 +0.5*fgkSSDFlexHeight[1]);
3924 TGeoVolume* laddercablesegmentbboxassembly =
3925 new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
3926 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3927 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3928 laddercablesegmentbboxtrans[i]);
3929/////////////////////////////////////////
3930// LadderSegmentArb8 Volume
3931/////////////////////////////////////////
3932 const Int_t kvertexnumber = 4;
3933 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3934 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3935 new TVector3*[kvertexnumber];
3936//Shape Vertex Positioning
3937 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3938 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3939 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3940 i*fgkSSDFlexHeight[0]);
3941 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3942 + fgkSSDFlexHeight[1]
3943 + i*fgkSSDFlexHeight[0]);
3944 laddercablesegmentvertexposition[i][3] =
3945 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3946 laddercablesegmentvertexposition[i][2]->Y());
3947 }
3948 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3949 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
a6e0ebfe 3950 const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
bf210566 3951 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3952 TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3953 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3954 GetArbShape(laddercablesegmentvertexposition[i],
3955 laddercablesegmentwidth[i],
3956 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3957 laddercablesegmentarbshapename[i]);
3958 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3959 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3960 TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3961 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3962 laddercablesegmentarb[i] =
3963 new TGeoVolume(laddercablesegmentarbname[i],
3964 laddercablesegmentarbshape[i],
3965 (i==0?fSSDAlTraceLadderCableMedium:
3966 fSSDKaptonLadderCableMedium));
3967 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3968 fColorPolyhamide);
d7599219 3969}
bf210566 3970 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3971 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3972 90.,90,-90.);
3973 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3974 0.,90.,0.);
3975 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3976 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3977 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3978 + fgkSSDFlexWidth[0],0.,0.,
3979 new TGeoRotation((*laddercablesegmentarbrot[1])
3980 *(*laddercablesegmentarbrot[0])));
3981 TGeoVolume* laddercablesegmentarbassembly =
3982 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3983 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3984 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3985 laddercablesegmentarbcombitrans);
3986/////////////////////////////////////////
3987// End Ladder Cable Volume
3988/////////////////////////////////////////
3989 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3990 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3991 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3992 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3993 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3994 0.5*ssdendladdercablelength,
3995 0.5*fgkSSDLadderCableWidth,
3996 0.5*fgkSSDFlexHeight[i]);
3997 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3998 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3999 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
4000 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
4001 ladderendcablesegmentbbox[i] =
4002 new TGeoVolume(ladderendcablesegmentbboxname[i],
4003 ladderendcablesegmentbboxshape[i],
4004 (i==0?fSSDAlTraceLadderCableMedium:
4005 fSSDKaptonLadderCableMedium));
4006 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
4007 fColorPolyhamide);
4008 }
4009 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
4010 ladderendcablesegmentbboxtrans[0] =
4011 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
4012 0.5*ssdendladdercablelength,
4013 0.5*fgkSSDLadderCableWidth,
4014 0.5*fgkSSDFlexHeight[0]);
4015 ladderendcablesegmentbboxtrans[1] =
4016 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
4017 0.5*ssdendladdercablelength,
4018 0.5*fgkSSDLadderCableWidth,
4019 fgkSSDFlexHeight[0]
4020 +0.5*fgkSSDFlexHeight[1]);
4021 TGeoVolume* ladderendcablesegmentbboxassembly =
4022 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
4023 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
4024 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
4025 ladderendcablesegmentbboxtrans[i]);
4026/////////////////////////////////////////
4027 TList* laddercablesegmentlist = new TList();
4028 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
4029 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
4030 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
4031 return laddercablesegmentlist;
4032 }
4033/////////////////////////////////////////////////////////////////////////////////
4034TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 4035 /////////////////////////////////////////////////////////////
bf210566 4036 // Method generating Ladder Cable Volumes Assemblies
44285dfa 4037 /////////////////////////////////////////////////////////////
bf210566 4038 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
4039 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
4040 for(Int_t i=0; i<n; i++){
4041 TGeoTranslation* laddercabletrans = new TGeoTranslation(
4042 i*(fgkCarbonFiberJunctionWidth),
4043 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4044 i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4045 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
4046 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
d7599219 4047 }
bf210566 4048 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
4049 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4050 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4051 (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4052 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
4053 return laddercable;
4054}
4055/////////////////////////////////////////////////////////////////////////////////
4056TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
4057 /////////////////////////////////////////////////////////////
4058 // Method generating Ladder Cable Volumes Assembly
4059 /////////////////////////////////////////////////////////////
4060 TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
a3f8715e 4061 char laddercabletransname[100];
bf210566 4062 for(Int_t i=0; i<n; i++){
4063 sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
4064 laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
4065 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
d7599219 4066 }
bf210566 4067 return laddercableassembly;
4068}
4069/////////////////////////////////////////////////////////////////////////////////
4070TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
4071 /////////////////////////////////////////////////////////////
4072 // Method generating Ladder Cable List Assemblies
4073 /////////////////////////////////////////////////////////////
4074 const Int_t kladdercableassemblynumber = 2;
4075 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
4076 TGeoVolume* ladderCable[kladdercableassemblynumber];
a3f8715e 4077 char laddercableassemblyname[100];
bf210566 4078 TList* laddercableassemblylist = new TList();
4079 for(Int_t i=0; i<kladdercableassemblynumber; i++){
4080 sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
4081 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
4082 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
4083 new TGeoCombiTrans((n-1)
4084 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4085 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
4086 0.,new TGeoRotation("",180,0.,0.)));
4087 laddercableassemblylist->Add(ladderCable[i]);
4088}
4089 return laddercableassemblylist;
4090}
4091///////////////////////////////////////////////////////////////////////////////
4092void AliITSv11GeometrySSD::SetLadderSegment(){
4093 /////////////////////////////////////////////////////////////
4094 // Method Generating Ladder Segment Array
4095 /////////////////////////////////////////////////////////////
4096 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
4097 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
4098 if(!fCreateMaterials) CreateMaterials();
4099 if(!fTransformationMatrices) CreateTransformationMatrices();
4100 if(!fBasicObjects) CreateBasicObjects();
4101 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
4102 // Placing Carbon Fiber Support
4103 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
4104 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4105 fcarbonfibersupportmatrix[j]);
4106 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4107 fcarbonfibersupportmatrix[j]);
d7599219 4108 }
bf210566 4109 // Placing Carbon Fiber Junction
4110 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
4111 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
4112 fcarbonfiberjunctionmatrix[j]);
4113 // Placing Carbon Fiber Lower Support
4114 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++)
4115 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
4116 fcarbonfiberlowersupportrans[j]);
4117 // Placing SSD Sensor Support
4118 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
4119 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
4120 fssdsensorsupport[1][i],
4121 j+1,fssdsensorsupportmatrix[j]);
4122 // Placing SSD Cooling Tube Support
4123 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
4124 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4125 fcoolingtubesupportmatrix[j]);
4126 // Placing SSD Cooling Tube
4127 for(Int_t j=0; j<2; j++)
4128 for(Int_t k=0; k<2; k++){
4129 fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]);
4130 fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]);
4131 }
4132 // Placing SSD Hybrid
4133 switch(i){
4134 case 0:
4135 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
4136 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4137 break;
4138 case 1:
4139 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
4140 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4141 break;
4142 }
4143 // Placing Cooling Block System
4144 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
4145 // Placing SSD Flex
4146 for(Int_t j=0; j<fgkflexnumber; j++){
4147 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
4148 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
4149 }
4150 }
d7599219 4151}
bf210566 4152///////////////////////////////////////////////////////////////////////////////
4153void AliITSv11GeometrySSD::SetEndLadderSegment(){
4154 /////////////////////////////////////////////////////////////
4155 // Method Generating End Ladder
4156 /////////////////////////////////////////////////////////////
4157 // End Ladder Carbon Fiber Junction
4158 /////////////////////////////////////////////////////////////
4159 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
4160 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
4161 if(!fCreateMaterials) CreateMaterials();
4162 if(!fTransformationMatrices) CreateTransformationMatrices();
4163 if(!fBasicObjects) CreateBasicObjects();
4164 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
4165 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
4166 fendladdersegment[i]->AddNode(j==2 ?
4167 fendladdercarbonfiberjunction[i][1] :
4168 fendladdercarbonfiberjunction[i][0],
4169 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
4170 }
4171 /////////////////////////////////////////////////////////////
4172 // End Ladder Carbon Fiber Support
4173 /////////////////////////////////////////////////////////////
4174 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
4175 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
4176 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4177 fendladdercarbonfibermatrix[i][j]);
4178 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4179 fendladdercarbonfibermatrix[i][j]);
4180 }
4181 /////////////////////////////////////////////////////////////
4182 // End Ladder Mounting Block
4183 /////////////////////////////////////////////////////////////
9b0c60ab 4184 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4185 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
e21cdd03 4186 fendladdermountingblockcombitrans[i]);
9b0c60ab 4187 /////////////////////////////////////////////////////////////
e5bf64ae 4188 // End Ladder Mounting Block Clip
9b0c60ab 4189 /////////////////////////////////////////////////////////////
4190 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4191 for(Int_t j=0; j<2; j++)
e21cdd03 4192 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
4193 fendladdermountingblockclipmatrix[i][j]);
bf210566 4194 /////////////////////////////////////////////////////////////
4195 // End Ladder Lower Supports
44285dfa 4196 /////////////////////////////////////////////////////////////
bf210566 4197 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
e21cdd03 4198 fendladderlowersupptrans[0]);
bf210566 4199 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
e21cdd03 4200 fendladderlowersupptrans[1]);
bf210566 4201 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
e21cdd03 4202 fendladderlowersupptrans[2]);
9b0c60ab 4203 /////////////////////////////////////////////////////////////
4204 // End Ladder Cooling Tube Support
4205 /////////////////////////////////////////////////////////////
4206 for(Int_t i=0; i<2; i++)
4207 for(Int_t j=0; j<(i==0?4:2); j++)
e21cdd03 4208 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4209 fendladdercoolingtubesupportmatrix[i][j]);
9b0c60ab 4210 /////////////////////////////////////////////////////////////
4211 // End Ladder Cooling Tube Support
4212 /////////////////////////////////////////////////////////////
ca86fdb4 4213// fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
4214// fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
9b0c60ab 4215 fendladdersegment[0]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[0][2]);
4216 fendladdersegment[0]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[0][3]);
4217 fendladdersegment[0]->AddNode(fendladdercoolingtube[2],1,fendladdercoolingtubematrix[0][4]);
4218 fendladdersegment[0]->AddNode(fendladdercoolingtube[2],2,fendladdercoolingtubematrix[0][5]);
4219 fendladdersegment[1]->AddNode(fendladdercoolingtube[3],1,fendladdercoolingtubematrix[1][0]);
4220 fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);
4221 fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);
ca86fdb4 4222 fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);
bf210566 4223}
4224///////////////////////////////////////////////////////////////////////////////
4225void AliITSv11GeometrySSD::SetLadder(){
4226 /////////////////////////////////////////////////////////////
4227 // Method Generating Ladder of Layer 5 and 6
44285dfa 4228 /////////////////////////////////////////////////////////////
bf210566 4229 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
4230 fgkSSDLay6SensorsNumber};
4231 /////////////////////////////////////////////////////////////////////////////
4232 /// Generating Ladder Mother Volume Containing Ladder
4233 /////////////////////////////////////////////////////////////////////////////
4234 TGeoXtru* laddershape[fgkladdernumber];
4235 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
4236 const Int_t kmothervertexnumber = 8;
4237 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
4238 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
4239 ///////////////////////
4240 // Setting the vertices
4241 ///////////////////////
4242 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
4243 * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
4244 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
0fb26117 4245 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
bf210566 4246 xmothervertex[0][1] = xmothervertex[0][0];
4247 ymothervertex[0][1] = 0.0;
4248 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
4249 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
4250 ymothervertex[0][2] = ymothervertex[0][1];
4251 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
4252 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
4253 xmothervertex[0][4] = -xmothervertex[0][3];
4254 ymothervertex[0][4] = ymothervertex[0][3];
4255 xmothervertex[0][5] = -xmothervertex[0][2];
4256 ymothervertex[0][5] = ymothervertex[0][2];
4257 xmothervertex[0][6] = -xmothervertex[0][1];
4258 ymothervertex[0][6] = ymothervertex[0][1];
4259 xmothervertex[0][7] = -xmothervertex[0][0];
4260 ymothervertex[0][7] = ymothervertex[0][0];
4261 for(Int_t i=0; i<kmothervertexnumber; i++){
4262 xmothervertex[1][i] = xmothervertex[0][i];
4263 ymothervertex[1][i] = ymothervertex[0][i];
4264 }
0fb26117 4265///////////////////////////////////////////////////////////////////////////
4266// Disalignement Mother Volume corrections 25/08/08
4267///////////////////////////////////////////////////////////////////////////
4268 TGeoXtru* leftladdershape[fgkladdernumber];
4269 TGeoXtru* centersensorladdershape[fgkladdernumber];
4270 TGeoXtru* rightladdershape[fgkladdernumber];
bf210566 4271 for(Int_t i=0; i<fgkladdernumber; i++){
0fb26117 4272 leftladdershape[i] = new TGeoXtru(2);
4273 centersensorladdershape[i] = new TGeoXtru(2);
4274 rightladdershape[i] = new TGeoXtru(2);
4275 }
4276 //////////////////////////////////////
4277 // Setting the names for shapes
4278 //////////////////////////////////////
4279 leftladdershape[0]->SetName("Lay5LeftLadderSegmentContainer");
4280 leftladdershape[1]->SetName("Lay6LeftLadderSegmentContainer");
4281 centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
4282 centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
4283 rightladdershape[0]->SetName("Lay5RightLadderSegmentContainer");
4284 rightladdershape[1]->SetName("Lay6RightLadderSegmentContainer");
4285 //////////////////////////////////////
4286 Double_t xleftladdervertex[fgkladdernumber][kmothervertexnumber];
4287 Double_t yleftladdervertex[fgkladdernumber][kmothervertexnumber];
4288 Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
4289 Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
4290 Double_t xrightladdervertex[fgkladdernumber][kmothervertexnumber];
4291 Double_t yrightladdervertex[fgkladdernumber][kmothervertexnumber];
4292 for(Int_t i=0; i<fgkladdernumber; i++)
4293 for(Int_t j=0; j<kmothervertexnumber; j++){
4294 xleftladdervertex[i][j] = xmothervertex[i][j];
4295 yleftladdervertex[i][j] = ymothervertex[i][j];
4296 xcentersensorvertex[i][j] = xmothervertex[i][j];
4297 ycentersensorvertex[i][j] = ymothervertex[i][j];
4298 xrightladdervertex[i][j] = xmothervertex[i][j];
4299 yrightladdervertex[i][j] = ymothervertex[i][j];
4300 }
4301 xcentersensorvertex[0][0] -= fgkSSDModuleSideDisalignment;
4302 xcentersensorvertex[0][1] = xcentersensorvertex[0][0];
4303 xcentersensorvertex[0][6] = -xcentersensorvertex[0][1];
4304 xcentersensorvertex[0][7] = -xcentersensorvertex[0][0];
4305
4306 xcentersensorvertex[1][0] = xcentersensorvertex[0][0];
4307 xcentersensorvertex[1][1] = xcentersensorvertex[0][1];
4308 xcentersensorvertex[1][6] = xcentersensorvertex[0][6];
4309 xcentersensorvertex[1][7] = xcentersensorvertex[0][7];
4310
baeecde0 4311 ycentersensorvertex[0][0] -= fgkSSDModuleVerticalDisalignment;
0fb26117 4312 ycentersensorvertex[0][7] = ycentersensorvertex[0][0];
4313
4314 ycentersensorvertex[1][0] = ycentersensorvertex[0][0];
4315 ycentersensorvertex[1][7] = ycentersensorvertex[0][7];
4316 for(Int_t i=0; i<fgkladdernumber; i++){
4317 // Left Ladder Piece
4318 leftladdershape[i]->DefinePolygon(kmothervertexnumber,xleftladdervertex[i],
4319 yleftladdervertex[i]);
4320 leftladdershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4321 leftladdershape[i]->DefineSection(1,-fgkEndLadderCarbonFiberLowerJunctionLength[1]
4322 +1.45*fgkSSDMountingBlockWidth);
4323 // Center Ladder Piece
4324 centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
4325 ycentersensorvertex[i]);
4326 centersensorladdershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]
4327 + 1.45*fgkSSDMountingBlockWidth);
4328 centersensorladdershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4329 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4330 - 2.4*fgkSSDMountingBlockWidth);
4331 // Right Ladder Piece
4332 rightladdershape[i]->DefinePolygon(kmothervertexnumber,xrightladdervertex[i],
4333 yrightladdervertex[i]);
4334 rightladdershape[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4335 +fgkEndLadderCarbonFiberLowerJunctionLength[0]
4336 -2.4*fgkSSDMountingBlockWidth);
4337 rightladdershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
bf210566 4338 +fgkEndLadderCarbonFiberLowerJunctionLength[0]);
0fb26117 4339 }
4340 TGeoCompositeShape* laddershapecontainer[2];
4341 laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4342 "Lay5LeftLadderSegmentContainer+Lay5CenterSensorContainer+Lay5RightLadderSegmentContainer");
4343 laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4344 "Lay6LeftLadderSegmentContainer+Lay6CenterSensorContainer+Lay6RightLadderSegmentContainer");
4345 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4346 for(Int_t i=0; i<fgkladdernumber; i++){
4347 fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4348 fladder[i]->SetLineColor(4);
4349 }
bf210566 4350///////////////////////////////////////////////////////////////////////////
4351 if(!fCreateMaterials) CreateMaterials();
4352 if(!fTransformationMatrices) CreateTransformationMatrices();
4353 if(!fBasicObjects) CreateBasicObjects();
4354 SetLadderSegment();
4355 SetEndLadderSegment();
4356 for(Int_t i=0; i<fgkladdernumber; i++){
4357 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4358 //////////////////////////
4359 /// Placing Ladder Segment
4360 //////////////////////////
4361 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4362 fladdersegment[i==0 ? 1 : 0],
4363 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4364 //////////////////////////
4365 /// Placing SSD Sensor
4366 //////////////////////////
ca86fdb4 4367 if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
bf210566 4368 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4369 fssdsensormatrix[i][j]);
4370 }
4371 ///////////////////////////////
4372 /// Placing End Ladder Segment
4373 ///////////////////////////////
4374 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4375 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4376 }
d7599219 4377/////////////////////////////////////////////////////////////////////////////
4378/// Placing Ladder Cables
4379/////////////////////////////////////////////////////////////////////////////
bf210566 4380 Int_t sidecablenumber[2][2];
4381 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4382 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4383 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4384 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4385 Double_t carbonfibertomoduleposition[3];
4386 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4387 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4388 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4389 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4390 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4391 - fgkSSDSensorCenterSupportThickness[0]);
4392 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4393 + 0.5*fgkCoolingTubeSupportHeight
4394 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4395 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4396 Double_t ssdendladdercablelength[4];
4397 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4398 + fgkSSDSensorLength
4399 - fgkSSDModuleStiffenerPosition[1]
4400 - fgkSSDStiffenerWidth
4401 - fgkSSDFlexWidth[0]
bf210566 4402 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4403 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4404 + fgkSSDModuleStiffenerPosition[1]
4405 + fgkSSDStiffenerWidth
bf210566 4406 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4407 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4408 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4409 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4410 - kendladdercablecorrection;
44285dfa 4411 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4412 + carbonfibertomoduleposition[1]
d7599219 4413 - fgkSSDModuleStiffenerPosition[1]
4414 - fgkSSDStiffenerWidth)
bf210566 4415 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
44285dfa 4416 TList* laddercableassemblylist[4];
4417 const Int_t kendladdercablesnumber = 4;
bf210566 4418 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4419 for(Int_t j=0; j<kendladdercablesnumber; j++){
4420 laddercableassemblylist[j] =
4421 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4422 ssdendladdercablelength[j]);
0fb26117 4423 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4424 j<2?1:2,fladdercablematrix[i][j]);
bf210566 4425 }
bf210566 4426}
4427////////////////////////////////////////////////////////////////////////////////
4428void AliITSv11GeometrySSD::SetLayer(){
d7599219 4429////////////////////////////////////////////////////////////////////////////////
bf210566 4430 // Creating Ladder of Layer 5 and Layer 6
4431 /////////////////////////////////////////////////////////////
4432 if(!fCreateMaterials) CreateMaterials();
4433 if(!fTransformationMatrices) CreateTransformationMatrices();
4434 if(!fBasicObjects) CreateBasicObjects();
4435 SetLadder(); // Generating the ladder of Layer5 and Layer6
4436 const Int_t kssdlayladdernumber[fgklayernumber] =
4437 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4438 /////////////////////////////////////////////////////////////
4439 // Generating mother volumes for Layer5 and Layer6
4440 /////////////////////////////////////////////////////////////
e5bf64ae 4441 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4442 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
bf210566 4443 Int_t *ladderindex[fgklayernumber];
4444 Int_t index[fgklayernumber] = {8,9};
4445 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4446 for(Int_t i=0; i<fgklayernumber; i++)
4447 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4448 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4449 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4450 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4451 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4452 }
44285dfa 4453 /////////////////////////////////////////////////////////////
bf210566 4454 // Deallocating memory
4455 /////////////////////////////////////////////////////////////
9b0c60ab 4456 for(Int_t i=0; i<fgklayernumber; i++) delete ladderindex[i];
d7599219 4457}
4458////////////////////////////////////////////////////////////////////////////////
4459void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4460 /////////////////////////////////////////////////////////////
4461 // Insert the layer 5 in the mother volume.
4462 /////////////////////////////////////////////////////////////
4463 if (! moth) {
4464 printf("Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!\n");
4465 return;
4466 };
bf210566 4467 if(!fSSDLayer5) SetLayer();
4468 fMotherVol = moth;
4469 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4470 + fgkLay5CenterITSPosition);
4471 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4472 }
d7599219 4473////////////////////////////////////////////////////////////////////////////////
4474void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4475 /////////////////////////////////////////////////////////////
4476 // Insert the layer 6 in the mother volume.
4477 /////////////////////////////////////////////////////////////
4478 if (! moth) {
4479 printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4480 return;
4481 };
bf210566 4482 if(!fSSDLayer6) SetLayer();
4483 fMotherVol = moth;
4484 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4485 + fgkLay6CenterITSPosition);
4486 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4487 }
bf210566 4488 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4489 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4490 /////////////////////////////////////////////////////////////
4491 // Method generating the Arc structure of Ladder Support
4492 /////////////////////////////////////////////////////////////
4493 const Int_t kssdlayladdernumber[fgklayernumber] =
4494 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4495 Double_t mountingsupportedge[fgklayernumber];
4496 Double_t mountingblockratio[fgklayernumber];
4497 Double_t theta[fgklayernumber];
4498 Double_t phi[fgklayernumber];
4499 Double_t psi0[fgklayernumber];
4500 Double_t deltapsi[fgklayernumber];
4501 TVector3* mountingsupportedgevector[fgklayernumber];
4502 for(Int_t i=0; i<fgklayernumber; i++){
4503 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4504 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4505 *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4506 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4507 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4508 / kssdlayladdernumber[i])));
4509 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4510 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4511 mountingsupportedgevector[i] = new TVector3();
4512 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4513 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(1.
4514 -TMath::Power(mountingsupportedgevector[i]->X()
4515 / fgkMountingBlockSupportRadius[i],2)));
4516 psi0[i] = 0.5*TMath::Pi()-phi[i];
4517 deltapsi[i] = (theta[i]+phi[i])/nedges;
4518 }
4519 TVector3** vertex[fgklayernumber];
4520 TList* vertexlist[fgklayernumber];
4521 Int_t indexedge[fgklayernumber] = {0,0};
4522 for(Int_t i=0; i<fgklayernumber; i++){
4523 vertex[i] = new TVector3*[nedges+1];
4524 vertexlist[i] = new TList();
4525 }
4526 for(Int_t i=0; i<fgklayernumber; i++){
4527 for(Int_t j=0; j<nedges+1; j++){
4528 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4529 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4530 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4531 vertexlist[i]->Add(vertex[i][j]);
4532 }
4533 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4534 }
4535 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4536 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4537 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4538 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4539 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4540 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4541 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4542 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4543 for(Int_t i=0; i<fgklayernumber; i++){
4544 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4545 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4546 xcentervertex[i] = new Double_t[indexedge[i]+3];
4547 ycentervertex[i] = new Double_t[indexedge[i]+3];
4548 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4549 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4550 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4551 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4552 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4553 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4554 ((TVector3*)vertexlist[i]->At(j))->X();
4555 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4556 ((TVector3*)vertexlist[i]->At(j))->Y();
4557 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4558 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4559 if(j<indexedge[i]+1){
4560 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4561 ((TVector3*)vertexlist[i]->At(j))->X();
4562 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4563 ((TVector3*)vertexlist[i]->At(j))->Y();
4564 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4565 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4566 }
4567 }
4568 xsidevertex[i][1] = xsidevertex[i][0];
4569 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4570 xsidevertex[i][2] = xsidevertex[i][3];
4571 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4572 xcentervertex[i][1] = xcentervertex[i][0];
4573 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4574 xcentervertex[i][2] = xcentervertex[i][3];
4575 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4576 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4577 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4578 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4579 ycenterlowervertex[i][0] = ysidevertex[i][0];
4580 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4581 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4582 }
4583 /////////////////////////////////////////////////////////////
4584 // Building the Arc Structure of Ladder Supports
4585 /////////////////////////////////////////////////////////////
4586 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4587 TGeoXtru* centermountingsupportshape[fgklayernumber];
4588 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4589 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4590 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4591 TGeoVolume* centermountingblocksupport[fgklayernumber];
4592 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4593 TGeoVolume* centerladdersupportpiece[fgklayernumber];
a3f8715e 4594 char sidemountingblockname[100];
4595 char centermountingblockname[100];
4596 char sideladdersupportpiecename[100];
4597 char centerladdersupportpiecename[100];
9b0c60ab 4598 for(Int_t i=0; i<fgklayernumber; i++){
4599 sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4600 sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4601 sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4602 sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4603 sidemountingblocksupportshape[i] = new TGeoXtru(2);
4604 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4605 xsidevertex[i],ysidevertex[i]);
4606 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4607 -fgkMountingBlockSupportWidth[0]);
4608 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4609 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4610 sidemountingblocksupportshape[i],
4611 fSSDAlCoolBlockMedium);
4612 sidemountingblocksupport[i]->SetLineColor(9);
4613 centermountingsupportshape[i] = new TGeoXtru(2);
4614 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4615 xcentervertex[i],ycentervertex[i]);
4616 centermountingsupportshape[i]->DefineSection(0,0.);
4617 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4618 -fgkMountingBlockSupportWidth[0]);
4619 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4620 centermountingsupportshape[i],
4621 fSSDAlCoolBlockMedium);
4622 centermountingblocksupport[i]->SetLineColor(9);
4623 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4624 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4625 xsidelowervertex[i],ysidelowervertex[i]);
4626 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4627 -fgkMountingBlockSupportWidth[0]);
4628 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4629 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4630 sideladdersupportpieceshape[i],
e21cdd03 4631 fSSDCarbonFiberMedium);
9b0c60ab 4632 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4633 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4634 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4635 xcenterlowervertex[i],ycenterlowervertex[i]);
4636 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4637 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4638 -fgkMountingBlockSupportWidth[0]);
4639 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4640 centerladdersupportpieceshape[i],
e21cdd03 4641 fSSDCarbonFiberMedium);
9b0c60ab 4642 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4643 }
4644 /////////////////////////////////////////////////////////////
4645 // Building the Up Structure of Ladder Supports
4646 /////////////////////////////////////////////////////////////
4647 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4648 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4649 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4650 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4651 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4652 //////////////////////////////////////////////////////////
4653 // Setting the volume for TGeoXtru Mounting Block Piece
4654 //////////////////////////////////////////////////////////
4655 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4656 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4657 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4658 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4659 TGeoVolume* mountingblockpieceup[fgklayernumber];
4660 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4661 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4662 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4663 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
a3f8715e 4664 char mountingblockpiecedownname[100];
4665 char mountingblockpieceupname[100];
9b0c60ab 4666 for(Int_t i=0; i<fgklayernumber; i++){
4667 ///////////////////////////
4668 // Mounting Block Down Vertex
4669 ///////////////////////////
4670 mountingblockpiecedownshape[i] = new TGeoXtru(2);
4671 sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4672 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4673 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4674 + fgkMountingBlockSupportDownHeight;
4675 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4676 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4677 + fgkSSDMountingBlockHeight[1]
4678 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4679 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4680 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4681 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4682 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4683 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4684 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4685 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4686 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4687 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4688 + fgkSSDMountingBlockHeight[2]
4689 - fgkSSDMountingBlockHeight[0];
4690 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4691 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4692 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4693 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4694 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4695 mountingblockpiecedownyvertex[i]);
4696 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4697 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4698 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
e21cdd03 4699 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
9b0c60ab 4700 mountingblockpiecedown[i]->SetLineColor(fColorG10);
4701 ///////////////////////////
4702 // Mounting Block Up Vertex
4703 ///////////////////////////
4704 mountingblockpieceupshape[i] = new TGeoXtru(2);
4705 sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4706 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4707 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4708 + fgkMountingBlockSupportUpHeight[i];
4709 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4710 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4711 + fgkSSDMountingBlockHeight[1]
4712 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4713 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4714 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4715 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4716 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4717 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4718 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4719 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4720 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4721 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4722 + fgkSSDMountingBlockHeight[2]
4723 - fgkSSDMountingBlockHeight[0];
4724 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4725 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4726 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4727 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4728 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4729 mountingblockpieceupyvertex[i]);
4730 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4731 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4732 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
e21cdd03 4733 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
9b0c60ab 4734 mountingblockpieceup[i]->SetLineColor(fColorG10);
4735 }
4736 ///////////////////////////////////////////////////////////////////
4737 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4738 ///////////////////////////////////////////////////////////////////
4739 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4740 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4741 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4742 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4743 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4744 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4745 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4746 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
a3f8715e 4747 char mountingblocksupportrapezoidowname[100];
4748 char mountingblocksupportrapezoidupname[100];
9b0c60ab 4749 Double_t scalefactor = 3./4.;
4750 for(Int_t i=0; i<fgklayernumber; i++){
4751 ////////////////////////////////////////////
4752 // Mounting Block Support Down Trapezoid Vertex
4753 ////////////////////////////////////////////
4754 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4755 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4756 - mountingsupportedge[i];
4757 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4758 mountingblocksupportrapezoidownxvertex[i][1] =
4759 mountingblocksupportrapezoidownxvertex[i][0];
4760 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4761 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4762 - mountingblockpiecedownyvertex[i][0]);
4763 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4764 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4765 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4766 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4767 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4768 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4769 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4770 mountingblocksupportrapezoidownyvertex[i]);
4771 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4772 -fgkMountingBlockSupportWidth[0]);
4773 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4774 sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4775 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
e21cdd03 4776 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4777 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4778 ////////////////////////////////////////////
4779 // Mounting Block Support Up Trapezoid Vertex
4780 ////////////////////////////////////////////
4781 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4782 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4783 - mountingsupportedge[i];
4784 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4785 mountingblocksupportrapezoidupxvertex[i][1] =
4786 mountingblocksupportrapezoidupxvertex[i][0];
4787 mountingblocksupportrapezoidupyvertex[i][1] =
4788 mountingblockpieceupyvertex[i][0]
4789 + scalefactor*(mountingblockpieceupyvertex[i][1]
4790 - mountingblockpieceupyvertex[i][0]);
4791 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4792 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4793 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4794 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4795 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4796 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4797 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4798 mountingblocksupportrapezoidupyvertex[i]);
4799 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4800 -fgkMountingBlockSupportWidth[0]);
4801 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4802 sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4803 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
e21cdd03 4804 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4805 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4806 }
4807 ///////////////////////////////////////////////////////////////////
4808 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4809 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4810 Double_t boxoriginup[fgklayernumber][2][3];
4811 Double_t boxorigindown[fgklayernumber][2][3];
a3f8715e 4812 char mountingblocksupportboxdownname[100];
4813 char mountingblocksupportboxupname[100];
9b0c60ab 4814 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4815 mountingblocksupportrot->SetAngles(90.,180.,-90);
4816 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4817 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4818 TGeoHMatrix* laddersupportmatrix[2];
4819 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4820 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4821 /////////////////////////////////////////////////////////////
4822 // Creating Mother Volume for Containment
4823 /////////////////////////////////////////////////////////////
4824 Double_t *xmothervertex[fgklayernumber];
4825 Double_t *ymothervertex[fgklayernumber];
4826 for(Int_t i=0; i<fgklayernumber; i++){
4827 xmothervertex[i] = new Double_t[8];
4828 ymothervertex[i] = new Double_t[8];
4829 }
4830 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4831 TGeoVolume* downmotherladdersupport[fgklayernumber];
4832 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
9f5fafaf 4833// TGeoVolume* upmotherladdersupport[fgklayernumber];
4834 TGeoVolumeAssembly* upmotherladdersupport[fgklayernumber];
a3f8715e 4835 char upmotheladdersupportname[100];
4836 char downmotheladdersupportname[100];
9b0c60ab 4837 for(Int_t i=0; i<fgklayernumber; i++){
4838 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4839 - mountingsupportedge[i];
4840 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4841 xmothervertex[i][1] = xmothervertex[i][0];
4842 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4843 + fgkMountingBlockSupportWidth[0];
4844 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4845 ymothervertex[i][2] = ymothervertex[i][1];
4846 xmothervertex[i][3] = xmothervertex[i][2];
4847 ymothervertex[i][3] = -ymothervertex[i][0];
4848 xmothervertex[i][4] = -xmothervertex[i][0];
4849 ymothervertex[i][4] = ymothervertex[i][3];
4850 xmothervertex[i][5] = xmothervertex[i][4];
4851 ymothervertex[i][5] = -ymothervertex[i][1];
4852 xmothervertex[i][6] = -xmothervertex[i][2];
4853 ymothervertex[i][6] = ymothervertex[i][5];
4854 xmothervertex[i][7] = xmothervertex[i][6];
4855 ymothervertex[i][7] = ymothervertex[i][0];
4856 sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4857 sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
4858 downmotherladdersupportshape[i] = new TGeoXtru(2);
4859 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4860 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4861 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4862 + fgkMountingBlockSupportDownHeight
4863 + fgkSSDMountingBlockHeight[1]
4864 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4865 - fgkSSDModuleCoolingBlockToSensor);
9b0c60ab 4866 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4867 downmotherladdersupportshape[i],fSSDAir);
4868 upmotherladdersupportshape[i] = new TGeoXtru(2);
4869 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4870 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4871 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4872 + fgkMountingBlockSupportUpHeight[i]
4873 + fgkSSDMountingBlockHeight[1]
4874 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4875 - fgkSSDModuleCoolingBlockToSensor);
9f5fafaf 4876 upmotherladdersupport[i] = new TGeoVolumeAssembly(upmotheladdersupportname);
4877// upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4878// upmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4879 }
4880 for(Int_t i=0; i<fgklayernumber; i++){
4881 /////////////////////////
4882 // Setting the box origin
4883 /////////////////////////
4884 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4885 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
4886 + 0.5*fgkMountingBlockSupportDownHeight;
4887 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4888 - 0.5*fgkMountingBlockSupportWidth[0];
4889
4890 boxorigindown[i][1][0] = 0.0;
4891 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4892 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4893 - fgkMountingBlockSupportWidth[0]);
4894
4895 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4896 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4897 + 0.5*fgkMountingBlockSupportUpHeight[i];
4898 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4899 - 0.5*fgkMountingBlockSupportWidth[0];
4900
4901 boxoriginup[i][1][0] = 0.0;
4902 boxoriginup[i][1][1] = fgkMountingBlockSupportRadius[i]
4903 + 0.5*fgkMountingBlockSupportUpHeight[i];
4904 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4905 - fgkMountingBlockSupportWidth[0]);
4906
4907 /////////////////////////
4908 // Setting the boxes
4909 /////////////////////////
4910 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4911 + fgkSSDMountingBlockLength[0]),
4912 0.5*fgkMountingBlockSupportDownHeight,
4913 0.5*fgkMountingBlockSupportWidth[0],
4914 boxorigindown[i][0]);
4915 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4916 0.5*fgkMountingBlockSupportDownHeight,
4917 0.5*(fgkMountingBlockSupportWidth[1]
4918 - fgkMountingBlockSupportWidth[0]),
4919 boxorigindown[i][1]);
4920
4921 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4922 + fgkSSDMountingBlockLength[0]),
4923 0.5*fgkMountingBlockSupportUpHeight[i],
4924 0.5*fgkMountingBlockSupportWidth[0],
4925 boxoriginup[i][0]);
4926
4927 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4928 0.5*fgkMountingBlockSupportUpHeight[i],
4929 0.5*(fgkMountingBlockSupportWidth[1]
4930 - fgkMountingBlockSupportWidth[0]),
4931 boxoriginup[i][1]);
4932 ///////////////////////////////////////
4933 // Adding the Volumes to Mother Volume
4934 ///////////////////////////////////////
4935 for(Int_t j=0; j<2; j++){
4936 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4937 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4938 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4939 mountingblocksupportboxdownshape[i][j],
e21cdd03 4940 fSSDCarbonFiberMedium);
9b0c60ab 4941 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4942 mountingblocksupportboxupshape[i][j],
e21cdd03 4943 fSSDCarbonFiberMedium);
9b0c60ab 4944 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4945 mountingblocksupportboxup[i][j]->SetLineColor(9);
4946 for(Int_t k=0; k<2; k++){
4947 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
9f5fafaf 4948// upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
9b0c60ab 4949 }
4950 }
4951 for(Int_t k=0; k<2; k++){
4952 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4953 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4954 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4955 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4956 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4957 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4958 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
9f5fafaf 4959// upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4960// upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4961// upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4962// upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4963// upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4964 }
4965 }
4966 TList* laddersupportlist = new TList();
4967 laddersupportlist->Add(downmotherladdersupport[0]);
4968 laddersupportlist->Add(upmotherladdersupport[0]);
4969 laddersupportlist->Add(downmotherladdersupport[1]);
4970 laddersupportlist->Add(upmotherladdersupport[1]);
4971 /////////////////////////////////////////////////////////////
4972 // Deallocating memory
4973 /////////////////////////////////////////////////////////////
4974 for(Int_t i=0; i<fgklayernumber; i++){
4975 for(Int_t j=0; j<nedges+1; j++)
4976 delete vertex[i][j];
4977 delete mountingsupportedgevector[i];
4978 delete [] vertex[i];
4979 delete vertexlist[i];
4980 delete [] xsidevertex[i];
4981 delete [] ysidevertex[i];
4982 delete [] xcentervertex[i];
4983 delete [] ycentervertex[i];
4984 delete [] xsidelowervertex[i];
4985 delete [] ysidelowervertex[i];
4986 delete [] xcenterlowervertex[i];
4987 delete [] ycenterlowervertex[i];
4988 }
3e008bd7 4989 delete [] xsidevertex;
4990 delete [] ysidevertex;
4991 delete [] xcentervertex;
4992 delete [] ycentervertex;
4993 delete [] xsidelowervertex;
4994 delete [] ysidelowervertex;
4995 delete [] xcenterlowervertex;
4996 delete [] ycenterlowervertex;
9b0c60ab 4997 delete globalrefladdersupportrot;
4998 delete mountingblocksupportrot;
4999 /////////////////////
5000 return laddersupportlist;
5001}
5002 ////////////////////////////////////////////////////////////////////////////////
5003void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
5004//////////////////////////////////////////
5005// Method Generating Ladder Support Ring
5006//////////////////////////////////////////
5007 if(!fCreateMaterials) CreateMaterials();
5008 if(!fTransformationMatrices) CreateTransformationMatrices();
5009 if(!fBasicObjects) CreateBasicObjects();
5010 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
5011 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
5012 const Int_t kssdlayladdernumber[fgklayernumber] =
5013 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
5014 Double_t mountingsupportedge[fgklayernumber];
5015 Double_t mountingblockratio[fgklayernumber];
5016 Double_t theta[fgklayernumber];
5017 Double_t phi[fgklayernumber];
5018 for(Int_t i=0; i<fgklayernumber; i++){
5019 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
5020 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
5021 *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
5022 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
5023 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
5024 / kssdlayladdernumber[i])));
5025 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
5026 / fgkMountingBlockSupportRadius[i]);
5027 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
5028 }
5029 TGeoRotation* globalrot = new TGeoRotation();
5030 globalrot->SetAngles(0.,-90.,0.);
5031 TGeoRotation** laddersupportrot[fgklayernumber];
5032 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
5033 for(Int_t i=0; i<fgklayernumber; i++){
5034 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
5035 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
5036 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
5037 laddersupportrot[i][j] = new TGeoRotation();
5038 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
5039 switch(i){
5040 case 0: //Ladder of Layer5
5041 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
5042 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
5043 laddersupportmatrix[i][j]);
5044 break;
5045 case 1: //Ladder of Layer6
5046 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
5047 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
5048 laddersupportmatrix[i][j]);
5049 break;
5050 }
5051 }
5052 }
5053 /////////////////////////////////////////////////////////////
5054 // Creating Lower Ladder Support
5055 /////////////////////////////////////////////////////////////
5056 TVector3** ringsupportvertex[fgklayernumber];
5057 Double_t angle = 360./nedges;
5058 for(Int_t i=0; i<fgklayernumber; i++){
5059 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
5060 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
5061 * TMath::Cos(theta[i]));
5062 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
5063 - mountingsupportedge[i],
5064 ringsupportvertex[i][0]->Y());
5065 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
5066 ringsupportvertex[i][1]->Y());
5067 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
5068 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
5069 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
5070 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
5071 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
5072 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
5073 }
5074 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
5075 for(Int_t j=0; j<nedges+1; j++){
5076 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
5077 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*CosD(90.0-j*angle),
5078 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*SinD(90.0-j*angle));
5079 }
5080 }
5081 Double_t **xmothervertex = new Double_t*[fgklayernumber];
5082 Double_t **ymothervertex = new Double_t*[fgklayernumber];
5083 for(Int_t i=0; i<fgklayernumber; i++){
5084 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5085 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5086 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
5087 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
5088 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
5089 }
5090 }
0e8760e5 5091////////////////////////////////////////////////////////////////////////////////
5092// Start Corrections 13/06/08
5093////////////////////////////////////////////////////////////////////////////////
a3f8715e 5094 char lowerladderpconsupportname[100];
0e8760e5 5095 TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
5096 TGeoVolume* lowerladderpconsupport[fgklayernumber];
5097 Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
5098 Double_t lowerladderpconradiusmax[fgklayernumber];
5099 Double_t lowerladderpconradiusmin[fgklayernumber];
5100 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5101 lowerladdersupportrot->SetAngles(90.,180.,-90);
5102 for(Int_t i=0; i<fgklayernumber; i++){
5103 lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
5104 * TMath::Cos(theta[i]);
5105 lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeigth;
5106 }
5107 for(Int_t i=0; i<fgklayernumber; i++){
5108/////////////////////////// Modified Version ?///////////////////
5109 lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
5110 for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
5111 lowerladderpconezsection[j],lowerladderpconradiusmin[i],
5112 lowerladderpconradiusmax[i]);
5113 sprintf(lowerladderpconsupportname,"LowerLadderPConSupportNameLay%d",i+5);
5114 lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
5115 lowerladderpconsupport[i]->SetLineColor(fColorAl);
5116 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
5117 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
5118 }
5119////////////////////////////////////////////////////////////////////////////////
5120// End Corrections 13/06/08
5121////////////////////////////////////////////////////////////////////////////////
5122 /*char lowerladdersupportname[30];
9b0c60ab 5123 TGeoXtru* lowerladdersupportshape[fgklayernumber];
5124 TGeoVolume* lowerladdersupport[fgklayernumber];
5125 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5126 lowerladdersupportrot->SetAngles(90.,180.,-90);
5127 for(Int_t i=0; i<fgklayernumber; i++){
5128 lowerladdersupportshape[i] = new TGeoXtru(2);
5129 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
5130 xmothervertex[i],ymothervertex[i]);
5131 lowerladdersupportshape[i]->DefineSection(0,0.);
5132 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
5133 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
5134 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
5135 lowerladdersupportshape[i],fSSDSupportRingAl);
5136 lowerladdersupport[i]->SetLineColor(fColorAl);
5137 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
5138 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
0e8760e5 5139 }*/
9b0c60ab 5140 /////////////////////////////////////////////////////////////
5141 // Deallocating memory
5142 /////////////////////////////////////////////////////////////
5143 for(Int_t i=0; i<fgklayernumber; i++){
5144 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
5145 delete ringsupportvertex[i][j];
5146 delete [] ringsupportvertex[i];
5147 }
5148 for(Int_t i=0; i<fgklayernumber; i++){
5149 delete [] xmothervertex[i];
5150 delete [] ymothervertex[i];
5151 }
5152 delete xmothervertex;
5153 delete ymothervertex;
5154 delete globalrot;
5155 for(Int_t i=0; i<fgklayernumber; i++){
5156 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
5157 delete laddersupportrot[i][j];
5158 delete [] laddersupportrot[i];
5159 }
5160 }
5161 ////////////////////////////////////////////////////////////////////////////////
5162 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
5163 /////////////////////////////////////////////////////////////
5164 // Method generating Endcap CoverPlate
5165 /////////////////////////////////////////////////////////////
5166 // Holes Definition
5167 ///////////////////
5168 Int_t nendcapcoverplateholedges = 30;
5169 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
5170 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
5171 0.5*fgkEndCapCoverPlateThickness};
851c0ce3 5172 TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
9b0c60ab 5173 nendcapcoverplateholedges,holesection);
5174 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 5175 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 5176 endcapcoverplatesmallhole->SetLineColor(6);
851c0ce3 5177 TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
9b0c60ab 5178 nendcapcoverplateholedges,holesection);
5179 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 5180 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 5181 endcapcoverplatebighole->SetLineColor(6);
5182 //////////////////////////
5183 // Screw Piece Definition
5184 //////////////////////////
5185 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
5186 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
5187 CosD(0.5*smallscrewangle),
5188 0.5*fgkEndCapCoverPlateThickness);
5189 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
5190 endcapsmallscrewpieceshape,
5191 fSSDCoolingTubePhynox);
5192 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
5193 ///////////////////
5194 // Box Definition
5195 ///////////////////
5196 TGeoBBox* endcapcoverplateboxshape[4];
5197 TGeoVolume* endcapcoverplatebox[4];
5198 Double_t boxorigin[5][3];
5199 boxorigin[0][0] = 0.;
5200 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
5201 boxorigin[0][2] = 0.;
5202
5203 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
5204 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
5205 boxorigin[1][2] = 0.;
5206
5207 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
5208 + fgkEndCapCoverPlateSmallHoleSeparation[1];
5209 boxorigin[2][1] = boxorigin[1][1];
5210 boxorigin[2][2] = 0.;
5211
5212 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
5213 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
5214 boxorigin[3][1] = boxorigin[1][1];
5215 boxorigin[3][2] = 0.;
5216
5217 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5218 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5219 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
5220 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5221
5222 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5223 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5224 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5225 + fgkEndCapCoverPlateSmallHoleRadius,
5226 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5227
5228 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5229 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5230 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5231 + fgkEndCapCoverPlateSmallHoleRadius,
5232 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5233
5234 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5235 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5236 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5237 + fgkEndCapCoverPlateSmallHoleRadius,
5238 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5239
5240 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 5241 fSSDAlCoolBlockMedium);
9b0c60ab 5242 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 5243 fSSDAlCoolBlockMedium);
9b0c60ab 5244 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 5245 fSSDAlCoolBlockMedium);
9b0c60ab 5246 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 5247 fSSDAlCoolBlockMedium);
9b0c60ab 5248 endcapcoverplatebox[0]->SetLineColor(6);
5249 endcapcoverplatebox[1]->SetLineColor(6);
5250 endcapcoverplatebox[2]->SetLineColor(6);
5251 endcapcoverplatebox[3]->SetLineColor(6);
5252 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5253 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5254 fgkEndCapCoverPlateSmallHoleRadius,
5255 0.5*fgkEndCapCoverPlateThickness,
5256 endcapfillingboxorigin);
5257 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 5258 fSSDAlCoolBlockMedium);
9b0c60ab 5259 endcapfillingbox->SetLineColor(6);
5260 ////////////////////////////
851c0ce3 5261 // Contour shape Definition
9b0c60ab 5262 ////////////////////////////
5263 const Int_t kcontourvertexnumber = 10;
5264 Double_t xcontourvertex[kcontourvertexnumber];
5265 Double_t ycontourvertex[kcontourvertexnumber];
5266 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5267 xcontourvertex[1] = xcontourvertex[0];
5268 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5269 xcontourvertex[3] = xcontourvertex[2];
5270 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5271 xcontourvertex[5] = xcontourvertex[4];
5272 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5273 xcontourvertex[7] = xcontourvertex[6];
5274 xcontourvertex[8] = xcontourvertex[4];
5275 xcontourvertex[9] = xcontourvertex[8];
5276 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5277 - (kendcapcoverplatesmallholenumber[1]-1)
5278 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5279 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5280 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5281 ycontourvertex[2] = ycontourvertex[1];
5282 ycontourvertex[3] = ycontourvertex[0];
5283 ycontourvertex[4] = ycontourvertex[3];
5284 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5285 ycontourvertex[6] = ycontourvertex[5];
5286 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5287 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5288 + fgkEndCapCoverPlateSmallHoleRadius;
5289 ycontourvertex[8] = ycontourvertex[7];
5290 ycontourvertex[9] = ycontourvertex[0];
851c0ce3 5291
5292 Double_t xboxin, dxboxin, yboxin, dyboxin;
5293 Double_t xboxout, dxboxout, yboxout, dyboxout;
5294 Double_t coordmin, coordmax;
5295 coordmin = -fgkEndCapCoverPlateLength[0];
5296 coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5297 xboxout = 0.5*(coordmin+coordmax);
5298 dxboxout = 0.5*(coordmax-coordmin);
5299 coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5300 - (kendcapcoverplatesmallholenumber[1]-1)
5301 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5302 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5303 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5304 yboxout = 0.5*(coordmin+coordmax);
5305 dyboxout = 0.5*(coordmax-coordmin);
5306 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5307 coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5308 xboxin = 0.5*(coordmin+coordmax);
5309 dxboxin = 0.5*(coordmax-coordmin);
5310 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5311 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5312 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5313 + fgkEndCapCoverPlateSmallHoleRadius;
5314 yboxin = 0.5*(coordmin+coordmax);
5315 dyboxin = 0.5*(coordmax-coordmin);
5316 new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5317 TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5318 xboxout, yboxout, 0.);
5319 trendCapCoverPlateContourboxout->RegisterYourself();
5320 new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5321 TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5322 xboxin, yboxin, 0.);
5323 trendCapCoverPlateContourboxin->RegisterYourself();
5324 TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5325 "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5326
e21cdd03 5327 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5328 fSSDAlCoolBlockMedium);
9b0c60ab 5329 contour->SetLineColor(6);
5330 /////////////////////////////
851c0ce3 5331 // Hole Contour Shape Definition
9b0c60ab 5332 ////////////////////////////
851c0ce3 5333 coordmin = xcontourvertex[0];
5334 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5335 xboxout = 0.5*(coordmin+coordmax);
5336 dxboxout = 0.5*(coordmax-coordmin);
5337 coordmin = ycontourvertex[1];
5338 coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5339 yboxout = 0.5*(coordmin+coordmax);
5340 dyboxout = 0.5*(coordmax-coordmin);
5341 coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5342 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5343 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5344 xboxin = 0.5*(coordmin+coordmax);
5345 dxboxin = 0.5*(coordmax-coordmin);
5346 coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5347 - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5348 coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5349 yboxin = 0.5*(coordmin+coordmax);
5350 dyboxin = 0.5*(coordmax-coordmin);
5351 new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5352 TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5353 xboxout, yboxout, 0.);
5354 trendCapCoverPlateContourboxout1->RegisterYourself();
5355 new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5356 TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5357 xboxin, yboxin, 0.);
5358 trendCapCoverPlateContourboxin1->RegisterYourself();
5359 TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5360 "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5361
5362
5363 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5364 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5365 xboxout = 0.5*(coordmin+coordmax);
5366 dxboxout = 0.5*(coordmax-coordmin);
5367 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5368 - fgkEndCapCoverPlateWidth[0]);
5369 coordmax = ycontourvertex[0];
5370 yboxout = 0.5*(coordmin+coordmax);
5371 dyboxout = 0.5*(coordmax-coordmin);
5372 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5373 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5374 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5375 xboxin = 0.5*(coordmin+coordmax);
5376 dxboxin = 0.5*(coordmax-coordmin);
5377 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5378 - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5379 - fgkEndCapCoverPlateWidth[0]
5380 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5381 coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5382 yboxin = 0.5*(coordmin+coordmax);
5383 dyboxin = 0.5*(coordmax-coordmin);
5384 new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5385 TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5386 xboxout, yboxout, 0.);
5387 trendCapCoverPlateContourboxout2->RegisterYourself();
5388 new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5389 TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5390 xboxin, yboxin, 0.);
5391 trendCapCoverPlateContourboxin2->RegisterYourself();
5392 TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5393 "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5394
5395// const Int_t kholecontourvertexnumber = 10;
5396
9b0c60ab 5397 Double_t xholecontourvertex[2][kcontourvertexnumber];
5398 Double_t yholecontourvertex[2][kcontourvertexnumber];
5399 xholecontourvertex[0][0] = xcontourvertex[0];
5400 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5401 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5402 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5403 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5404 + 0.5*(fgkEndCapCoverPlateLength[2]
5405 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5406 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5407 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5408 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5409 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5410 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5411 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5412
5413 yholecontourvertex[0][0] = ycontourvertex[1];
5414 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5415 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5416 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5417 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5418 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5419 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5420 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5421 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5422 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5423 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5424
5425 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5426 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5427 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5428 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5429 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5430 + 0.5*(fgkEndCapCoverPlateLength[2]
5431 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5432 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5433 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5434 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5435 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5436 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5437 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5438
5439 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5440 - fgkEndCapCoverPlateWidth[0]);
5441 yholecontourvertex[1][1] = ycontourvertex[0];
5442 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5443 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5444 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5445 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5446 - fgkEndCapCoverPlateWidth[0]
5447 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5448 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5449 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5450 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5451 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5452
9b0c60ab 5453 TGeoVolume* holecontour[2];
851c0ce3 5454 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
e21cdd03 5455 fSSDAlCoolBlockMedium);
9b0c60ab 5456 holecontour[0]->SetLineColor(6);
851c0ce3 5457 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
e21cdd03 5458 fSSDAlCoolBlockMedium);
9b0c60ab 5459 holecontour[1]->SetLineColor(6);
5460 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5461 + fgkEndCapCoverPlateLength[2],0.,0.);
5462 TGeoTranslation* bigholetrans[3];
5463 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5464 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5465 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5466 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5467 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5468 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5469 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5470 /////////////////////////////////
5471 // Mother Volume Xtru Definition
5472 /////////////////////////////////
5473 const Int_t kmothervertexnumber = 12;
5474 Double_t xmothervertex[kmothervertexnumber];
5475 Double_t ymothervertex[kmothervertexnumber];
5476 xmothervertex[0] = xcontourvertex[0];
5477 xmothervertex[1] = xmothervertex[0];
5478 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5479 xmothervertex[3] = xmothervertex[2];
5480 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5481 xmothervertex[5] = xmothervertex[4];
5482 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5483 xmothervertex[7] = xmothervertex[6];
5484 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5485 + fgkEndCapCoverPlateLength[2];
5486 xmothervertex[9] = xmothervertex[8];
5487 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5488 xmothervertex[11] = xmothervertex[10];
5489
5490 ymothervertex[0] = ycontourvertex[0];
5491 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5492 ymothervertex[2] = ymothervertex[1];
5493 ymothervertex[3] = ycontourvertex[1];
5494 ymothervertex[4] = ymothervertex[3];
5495 ymothervertex[5] = ymothervertex[1];
5496 ymothervertex[6] = ymothervertex[5];
5497 ymothervertex[7] = ymothervertex[0];
5498 ymothervertex[8] = ymothervertex[7];
5499 ymothervertex[9] = ymothervertex[8]
5500 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5501 ymothervertex[10] = ymothervertex[9];
5502 ymothervertex[11] = ymothervertex[8];
5503 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5504 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5505 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5506 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5507 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5508 ////////////////////////////////////////
5509 // Adding Nodes
5510 ////////////////////////////////////////
5511// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5512 TGeoTranslation*** endcapcoverplatesmallholetrans;
5513 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5514 Double_t transx[4] = {0,
5515 fgkEndCapCoverPlateSmallHoleSeparation[0],
5516 fgkEndCapCoverPlateSmallHoleSeparation[0]
5517 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5518 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5519 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5520 Int_t index = 0;
5521 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5522 endcapcoverplatesmallholetrans[i] =
5523 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5524 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5525 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5526 endcapcoverplatesmallholetrans[i][j] =
5527 new TGeoTranslation(transx[i],
5528 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5529 if(index!=10){
5530 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5531 index,endcapcoverplatesmallholetrans[i][j]);
5532 mothercoverplate->AddNode(endcapsmallscrewpiece,
5533 index,endcapcoverplatesmallholetrans[i][j]);
5534 }
5535 if(j<kendcapcoverplatesmallholenumber[1]-1)
5536 mothercoverplate->AddNode(endcapcoverplatebox[0],
5537 index,endcapcoverplatesmallholetrans[i][j]);
5538 }
5539 }
5540 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5541 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5542 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5543 mothercoverplate->AddNode(endcapfillingbox,1);
5544 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5545 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5546 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5547 mothercoverplate->AddNode(holecontour[0],1);
5548 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5549 mothercoverplate->AddNode(holecontour[1],1);
5550 mothercoverplate->AddNode(contour,1);
5551 /////////////////////////////////
5552 return mothercoverplate;
5553 }
5554 ////////////////////////////////////////////////////////////////////////////////
5555 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5556 /////////////////////////////////////////////////////////////
5557 // Getting EndCap Cooling Tube
5558 /////////////////////////////////////////////////////////////
5559 TGeoTorus* endcapcoolingtubetorushape[5];
5560 TGeoVolume* endcapcoolingtubetorus[5];
5561 TGeoTube* endcapcoolingtubeshape[4];
5562 TGeoVolume* endcapcoolingtube[4];
a3f8715e 5563 char endcapcoolingtubetorusname[100];
5564 char endcapcoolingtubename[100];
9b0c60ab 5565 TGeoTorus* endcapcoolingwatertubetorushape[5];
5566 TGeoVolume* endcapcoolingwatertubetorus[5];
5567 TGeoTube* endcapcoolingwatertubeshape[4];
5568 TGeoVolume* endcapcoolingwatertube[4];
a3f8715e 5569 char endcapcoolingwatertubetorusname[100];
5570 char endcapcoolingwatertubename[100];
9b0c60ab 5571 for(Int_t i=0; i<5; i++){
5572 sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5573 sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5574 sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5575 sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5576 if(i==3){
5577 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5578 fgkEndCapCoolingTubeRadiusMin,
5579 fgkEndCapCoolingTubeRadiusMax,
5580 90.0,fgkEndCapCoolingTubeAngle[3]);
5581 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5582 0.,fgkEndCapCoolingTubeRadiusMin,
5583 90.0,fgkEndCapCoolingTubeAngle[3]);
5584 }
5585 else{
5586 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5587 :fgkEndCapCoolingTubeAxialRadius[1],
5588 fgkEndCapCoolingTubeRadiusMin,
5589 fgkEndCapCoolingTubeRadiusMax,
5590 0.,fgkEndCapCoolingTubeAngle[i]);
5591 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5592 :fgkEndCapCoolingTubeAxialRadius[1],
5593 0.,fgkEndCapCoolingTubeRadiusMin,
5594 0.,fgkEndCapCoolingTubeAngle[i]);
5595 }
5596 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5597 endcapcoolingtubetorushape[i],
5598 fSSDCoolingTubePhynox);
5599 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5600 endcapcoolingwatertubetorushape[i],
5601 fSSDCoolingTubeWater);
5602 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5603 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5604 if(i<4){
5605 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5606 fgkEndCapCoolingTubeRadiusMax,
5607 0.5*fgkEndCapCoolingTubeLength[i]);
5608 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5609 0.5*fgkEndCapCoolingTubeLength[i]);
5610 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5611 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5612 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5613 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5614 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5615 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5616 }
5617 }
5618 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5619 /////////////////////////////////////////
5620 // Transformation for Volume Positioning
5621 /////////////////////////////////////////
5622 TGeoCombiTrans* coolingtubecombitrans[6];
5623 TGeoRotation* coolingtuberot[8];
5624 TGeoTranslation* coolingtubetrans[6];
5625 TGeoHMatrix* coolingtubematrix[4];
5626 TGeoCombiTrans* torustubecombitrans[4];
5627 TGeoRotation* torustuberot[7];
5628 TGeoTranslation* torustubetrans[4];
5629 TGeoHMatrix* torustubematrix[5];
5630 TGeoCombiTrans* coolingwatertubecombitrans[6];
5631 TGeoRotation* coolingwatertuberot[8];
5632 TGeoTranslation* coolingwatertubetrans[6];
5633 TGeoHMatrix* coolingwatertubematrix[4];
5634 TGeoCombiTrans* toruswatertubecombitrans[4];
5635 TGeoRotation* toruswatertuberot[7];
5636 TGeoTranslation* toruswatertubetrans[4];
5637 TGeoHMatrix* toruswatertubematrix[5];
5638 for(Int_t i=0; i<8; i++){
5639 if(i<6){
5640 coolingtubetrans[i] = new TGeoTranslation();
5641 coolingwatertubetrans[i] = new TGeoTranslation();
5642 }
5643 if(i<8){
5644 coolingtuberot[i] = new TGeoRotation();
5645 coolingwatertuberot[i] = new TGeoRotation();
5646 }
5647 if(i<4){
5648 torustubetrans[i] = new TGeoTranslation();
5649 toruswatertubetrans[i] = new TGeoTranslation();
5650 }
5651 if(i<7){
5652 torustuberot[i] = new TGeoRotation();
5653 toruswatertuberot[i] = new TGeoRotation();
5654 }
5655 }
5656 /////////////////////////////////////////
5657 // Transformation for Inox Volume Positioning
5658 /////////////////////////////////////////
5659 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5660 -endcapcoolingtubeshape[0]->GetDz(),0.);
5661 coolingtuberot[0]->SetAngles(0.,90.,0.);
5662 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5663 *coolingtuberot[0]);
5664
5665 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5666 coolingtuberot[1]->SetAngles(0.,90.,0.);
5667 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5668 *coolingtuberot[1]);
5669
5670 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5671 *CosD(fgkEndCapCoolingTubeAngle[0]),
5672 fgkEndCapCoolingTubeAxialRadius[0]
5673 *SinD(fgkEndCapCoolingTubeAngle[0]),
5674 0.);
5675 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5676 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5677 *coolingtuberot[2]);
5678
5679 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5680 * (*coolingtubecombitrans[1]));
5681
5682 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5683 endcapcoolingtubeshape[1]->GetDz());
5684 torustuberot[0]->SetAngles(0.,90.,0.);
5685 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5686
5687 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5688
5689 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5690 -endcapcoolingtubeshape[2]->GetDz(),0.);
5691 coolingtuberot[3]->SetAngles(0.,90.,0.);
5692 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5693 *coolingtuberot[3]);
5694 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5695 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5696 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5697
5698 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5699 endcapcoolingtubeshape[2]->GetDz());
5700 torustuberot[1]->SetAngles(0.,90.,0.);
5701 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5702 torustuberot[2]->SetAngles(180.,0.,0.);
5703 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5704 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5705
5706 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5707 -fgkEndCapCoolingTubeAxialRadius[0]);
5708 torustuberot[3]->SetAngles(0.,90.,0.);
5709 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5710 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5711 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5712 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5713
5714 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5715 fgkEndCapCoolingTubeAxialRadius[0],0.);
5716 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5717 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5718 *coolingtuberot[5]);
5719 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5720 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5721 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5722
5723 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5724 endcapcoolingtubeshape[0]->GetDz());
5725 torustuberot[5]->SetAngles(0.,90.,0.);
5726 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5727 torustuberot[6]->SetAngles(-90.,0.,0.);
5728 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5729 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5730
5731 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5732 endcapcoolingtubeshape[3]->GetDz(),0.);
5733 coolingtuberot[6]->SetAngles(0.,90.,0.);
5734 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5735 *coolingtuberot[6]);
5736 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5737 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5738 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5739 /////////////////////////////////////////
5740 // Transformation for Water Volume Positioning
5741 /////////////////////////////////////////
5742 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5743 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5744 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5745 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5746 *coolingwatertuberot[0]);
5747
5748 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5749 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5750 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5751 *coolingwatertuberot[1]);
5752
5753 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5754 *CosD(fgkEndCapCoolingTubeAngle[0]),
5755 fgkEndCapCoolingTubeAxialRadius[0]
5756 *SinD(fgkEndCapCoolingTubeAngle[0]),
5757 0.);
5758 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5759 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5760 *coolingwatertuberot[2]);
5761
5762 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5763 * (*coolingwatertubecombitrans[1]));
5764
5765 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5766 endcapcoolingwatertubeshape[1]->GetDz());
5767 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5768 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5769 *toruswatertuberot[0]);
5770
5771 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5772 * (*toruswatertubecombitrans[0]));
5773
5774 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5775 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5776 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5777 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5778 *coolingwatertuberot[3]);
5779 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5780 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5781 * (*coolingwatertubecombitrans[3]));
5782 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5783
5784 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5785 endcapcoolingwatertubeshape[2]->GetDz());
5786 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5787 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5788 *toruswatertuberot[1]);
5789 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5790 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5791 * (*toruswatertubecombitrans[1]));
5792 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5793
5794 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5795 -fgkEndCapCoolingTubeAxialRadius[0]);
5796 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5797 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5798 *toruswatertuberot[3]);
5799 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5800 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5801 * (*toruswatertubecombitrans[2]));
5802 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5803
5804 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5805 fgkEndCapCoolingTubeAxialRadius[0],0.);
5806 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5807 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5808 *coolingwatertuberot[5]);
5809 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5810 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5811 * (*coolingwatertubecombitrans[4]));
5812 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5813
5814 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5815 endcapcoolingwatertubeshape[0]->GetDz());
5816 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5817 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5818 *toruswatertuberot[5]);
5819 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5820 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5821 * (*toruswatertubecombitrans[3]));
5822 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5823
5824 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5825 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5826 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5827 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5828 *coolingwatertuberot[6]);
5829 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5830 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5831 * (*coolingwatertubecombitrans[5]));
5832 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5833 /////////////////////////////////////////
5834 // Positioning Volumes
5835 /////////////////////////////////////////
5836 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5837 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5838
5839 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5840 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5841
5842 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5843 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5844
5845 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5846 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5847
5848 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5849 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5850
5851 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5852 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5853
5854 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5855 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5856
5857 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5858 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5859
5860 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5861 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5862
5863 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5864 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5865 /////////////////////////////////////////////////////////////
5866 // Deallocating memory
5867 /////////////////////////////////////////////////////////////
5868 for(Int_t i=0; i<8; i++){
5869 if(i<6){
5870 delete coolingtubetrans[i];
5871 delete coolingwatertubetrans[i];
5872 if(i!=0){
5873 delete coolingtubecombitrans[i];
5874 delete coolingwatertubecombitrans[i];
5875 }
5876 }
5877 if(i<8){
5878 delete coolingtuberot[i];
5879 delete coolingwatertuberot[i];
5880 }
5881 if(i<4){
5882 delete torustubetrans[i];
5883 delete toruswatertubetrans[i];
5884 delete torustubecombitrans[i];
5885 delete toruswatertubecombitrans[i];
5886 }
5887 if(i<7){
5888 delete torustuberot[i];
5889 delete toruswatertuberot[i];
5890 }
5891 }
5892 /////////////////////////////////////////////////////////////
5893 return endcapcoolingtubemother;
5894 }
5895 ////////////////////////////////////////////////////////////////////////////////
5896 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5897 /////////////////////////////////////////////////////////////
5898 // Getting EndCap Cover Side
5899 /////////////////////////////////////////////////////////////
5900 const Int_t kendcapcoverholenumber[2] = {7,5};
5901 const Int_t kvertexnumber = 15;
5902 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5903 xvertex[0] = 0.0;
5904 xvertex[1] = xvertex[0];
5905 xvertex[2] = fgkEndCapSideCoverLength[0];
5906 xvertex[3] = fgkEndCapSideCoverLength[1];
5907 xvertex[4] = xvertex[3];
5908 xvertex[5] = fgkEndCapSideCoverLength[2];
5909 xvertex[6] = xvertex[5];
5910 xvertex[7] = xvertex[2];
5911 xvertex[8] = xvertex[7];
5912 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5913 xvertex[10] = xvertex[9];
5914 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5915 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5916 * fgkEndCapSideCoverLength[4];
5917 xvertex[12] = xvertex[11];
5918 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5919 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5920 * fgkEndCapSideCoverLength[4];
5921 xvertex[14] = xvertex[13];
5922 yvertex[0] = 0.0;
5923 yvertex[1] = fgkEndCapSideCoverWidth[0];
5924 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5925 yvertex[3] = yvertex[2];
5926 yvertex[4] = fgkEndCapSideCoverWidth[1];
5927 yvertex[5] = yvertex[4];
5928 yvertex[6] = yvertex[0];
5929 yvertex[7] = yvertex[6];
5930 yvertex[8] = fgkEndCapSideCoverWidth[6];
5931 yvertex[9] = yvertex[8];
5932 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5933 yvertex[11] = yvertex[10];
5934 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5935 yvertex[13] = yvertex[12];
5936 yvertex[14] = yvertex[6];
851c0ce3 5937 TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5938 endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5939 endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5940 endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5941 endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5942 TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5943 endcapsidecovershapein->SetName("endcapsidecovershapein");
5944 endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5945 endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5946 endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5947
5948
5949 TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
9b0c60ab 5950 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5951 endcapsidecovershape,fSSDCoolingTubePhynox);
5952 endcapsidecover->SetLineColor(fColorPhynox);
5953 ////////////////////////////////////////////
5954 // Defininition of Mother Volume
5955 ////////////////////////////////////////////
5956 const Int_t kmothervertexnumber = 7;
5957 Double_t xmothervertex[kmothervertexnumber];
5958 Double_t ymothervertex[kmothervertexnumber];
5959 for(Int_t i=0; i<kmothervertexnumber; i++){
5960 xmothervertex[i] = xvertex[i];
5961 ymothervertex[i] = yvertex[i];
5962 }
5963 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5964 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5965 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5966 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5967 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5968 endcapsidecovermothershape,fSSDAir);
5969 ////////////////////////////////////////////
5970 endcapsidecovermother->AddNode(endcapsidecover,1);
5971 TGeoBBox* endcapsidecoverboxshape[4];
5972 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5973 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5974 0.5*fgkEndCapSideCoverLength[4],
5975 0.5*fgkEndCapSideCoverThickness);
5976 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5977 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5978 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5979 - fgkEndCapSideCoverLength[4]),
5980 0.5*fgkEndCapSideCoverThickness);
5981 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5982 0.5*fgkEndCapSideCoverLength[4],
5983 0.5*fgkEndCapSideCoverThickness);
5984 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5985 0.5*fgkEndCapSideCoverWidth[5],
5986 0.5*fgkEndCapSideCoverThickness);
5987 TGeoVolume* endcapsidecoverbox[4];
5988 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5989 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5990 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5991 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5992 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5993// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5994 TGeoTranslation** endcapsidecoverboxtrans;
5995 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5996 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5997 + fgkEndCapSideCoverLength[0],
5998 endcapsidecoverboxshape[0]->GetDY()
5999 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
6000 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
6001 + xvertex[11],
6002 endcapsidecoverboxshape[1]->GetDY()
6003 + yvertex[12],0.);
6004 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
6005 + xvertex[11],
6006 endcapsidecoverboxshape[2]->GetDY()
6007 + yvertex[12]
6008 + 2.*endcapsidecoverboxshape[1]->GetDY()
6009 + fgkEndCapSideCoverWidth[5],0.);
6010 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
6011 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
6012 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
6013 for(Int_t i=0; i<2; i++)
6014 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
6015 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
6016 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
6017 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
6018 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
6019 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
6020 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
6021 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
6022 }
6023 for(Int_t i=0; i<2; i++)
6024 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
6025 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
6026 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
6027 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
6028 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
6029 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
6030 +fgkEndCapSideCoverLength[4]),0.0);
6031 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
6032 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
6033 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
6034 +i*(kendcapcoverholenumber[1]-1)+j]);
6035 }
6036 return endcapsidecovermother;
6037 }
6038 ////////////////////////////////////////////////////////////////////////////////
6039 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
6040 ////////////////////////////////////////////////////////////////////////////////
6041 // Method returning Interface Card A, Interface Card B, Supply Card
6042 ////////////////////////////////////////////////////////////////////////////////
6043 /////////////////////
6044 // Supply Card
6045 /////////////////////
6046 // Electronic Board Back Al Plane
6047 const Int_t kelectboardbackvertexnumber = 8;
6048 Double_t xelectboardback[kelectboardbackvertexnumber];
6049 Double_t yelectboardback[kelectboardbackvertexnumber];
6050 xelectboardback[0] = 0.0;
6051 xelectboardback[1] = xelectboardback[0];
6052 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
6053 xelectboardback[3] = xelectboardback[2];
6054 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
6055 xelectboardback[5] = xelectboardback[4];
6056 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
6057 xelectboardback[7] = xelectboardback[6];
6058
6059 yelectboardback[0] = 0.0;
6060 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
6061 yelectboardback[2] = yelectboardback[1];
6062 yelectboardback[3] = yelectboardback[0];
6063 yelectboardback[4] = yelectboardback[3];
6064 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
6065 yelectboardback[6] = yelectboardback[5];
6066 yelectboardback[7] = yelectboardback[4];
6067 TGeoXtru* electboardbackshape = new TGeoXtru(2);
6068 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
6069 xelectboardback,yelectboardback);
6070 electboardbackshape->DefineSection(0,0.0);
6071 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
6072 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
6073 electboardbackshape,fSSDSupportRingAl);
6074 electboardback->SetLineColor(fColorAl);
6075 // Electronic Board Kapton Layer
6076 const Int_t kelectlayervertexnumber = 8;
6077 Double_t xelectlayer[kelectlayervertexnumber];
6078 Double_t yelectlayer[kelectlayervertexnumber];
6079 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
6080 xelectlayer[1] = xelectlayer[0];
6081 xelectlayer[2] = fgkEndCapCardElectBoardLength;
6082 xelectlayer[3] = xelectlayer[2];
6083 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
6084
6085 yelectlayer[0] = 0.0;
6086 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
6087 yelectlayer[2] = yelectlayer[1];
6088 yelectlayer[3] = yelectlayer[0];
6089 yelectlayer[4] = yelectlayer[3];
6090 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
6091 yelectlayer[6] = yelectlayer[5];
6092 yelectlayer[7] = yelectlayer[4];
6093 TGeoXtru* electlayershape = new TGeoXtru(2);
6094 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
6095 electlayershape->DefineSection(0,0.0);
6096 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
6097 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
6098 electlayershape,fSSDKaptonFlexMedium);
6099 electlayer->SetLineColor(fColorKapton);
6100 // JMD Connector Female
6101 const Int_t kjmdconnectorvertexnumber = 6;
6102 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
6103 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
6104 xjmdconnectorvertex[0] = 0.0;
6105 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
6106 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
6107 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
6108 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
6109 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
6110
6111 yjmdconnectorvertex[0] = 0.0;
6112 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
6113 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
6114 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
6115 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
6116 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
6117 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
6118 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
6119 yjmdconnectorvertex);
6120 jmdconnectorshape->DefineSection(0,0.0);
6121 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
6122 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
6123 jmdconnectorshape,fSSDMountingBlockMedium);
6124 jmdconnector->SetLineColor(fColorG10);
6125 // Top Cable Connector
6126 const Int_t kcableconnectorvertexnumber = 8;
6127 Double_t xconnectorvertex[kcableconnectorvertexnumber];
6128 Double_t yconnectorvertex[kcableconnectorvertexnumber];
6129 xconnectorvertex[0] = 0.0;
6130 xconnectorvertex[1] = xconnectorvertex[0];
6131 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
6132 xconnectorvertex[3] = xconnectorvertex[2];
6133 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
6134 - fgkEndCapCardCableConnectorLength[2];
6135 xconnectorvertex[5] = xconnectorvertex[4];
6136 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
6137 xconnectorvertex[7] = xconnectorvertex[6];
6138
6139 yconnectorvertex[0] = 0.0;
6140 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
6141 yconnectorvertex[2] = yconnectorvertex[1];
6142 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
6143 yconnectorvertex[4] = yconnectorvertex[3];
6144 yconnectorvertex[5] = yconnectorvertex[1];
6145 yconnectorvertex[6] = yconnectorvertex[5];
6146 yconnectorvertex[7] = yconnectorvertex[0];
6147 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
6148 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
6149 yconnectorvertex);
6150 cableconnectorshape->DefineSection(0,0.0);
6151 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
6152 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
6153 cableconnectorshape,fSSDMountingBlockMedium);
6154 cableconnector->SetLineColor(fColorG10);
6155 // Strip Connection
6156 TGeoBBox* endcapstripconnectionshape =
6157 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
6158 0.5*fgkEndCapStripConnectionThickness,
6159 0.5*fgkEndCapStripConnectionWidth);
6160 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
6161 endcapstripconnectionshape,
6162 fSSDSupportRingAl);
6163 endcapstripconnection->SetLineColor(fColorAl);
6164 // Interface Card B
6165 const Int_t kcardBvertexnumber = 12;
6166 Double_t xcardBvertexnumber[kcardBvertexnumber];
6167 Double_t ycardBvertexnumber[kcardBvertexnumber];
6168
6169 xcardBvertexnumber[0] = 0.0;
6170 xcardBvertexnumber[1] = xcardBvertexnumber[0];
6171 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
6172 xcardBvertexnumber[3] = xcardBvertexnumber[2];
6173 xcardBvertexnumber[4] = xcardBvertexnumber[1];
6174 xcardBvertexnumber[5] = xcardBvertexnumber[4];
6175 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
6176 xcardBvertexnumber[7] = xcardBvertexnumber[6];
6177 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
6178 xcardBvertexnumber[9] = xcardBvertexnumber[8];
6179 xcardBvertexnumber[10] = xcardBvertexnumber[7];
6180 xcardBvertexnumber[11] = xcardBvertexnumber[10];
6181
6182 ycardBvertexnumber[0] = 0.0;
6183 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
6184 ycardBvertexnumber[2] = ycardBvertexnumber[1];
6185 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
6186 ycardBvertexnumber[4] = ycardBvertexnumber[3];
6187 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
6188 ycardBvertexnumber[6] = ycardBvertexnumber[5];
6189 ycardBvertexnumber[7] = ycardBvertexnumber[4];
6190 ycardBvertexnumber[8] = ycardBvertexnumber[7];
6191 ycardBvertexnumber[9] = ycardBvertexnumber[1];
6192 ycardBvertexnumber[10] = ycardBvertexnumber[9];
6193 ycardBvertexnumber[11] = ycardBvertexnumber[0];
6194
6195 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
6196 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
6197 interfacecardBshape->DefineSection(0,0.);
6198 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
6199 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
6200 fSSDMountingBlockMedium);
6201 interfacecardB->SetLineColor(46);
6202 // Interface Card B Electronic Board
6203 const Int_t kelectboardcardBvertexnumber = 14;
6204 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
6205 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
6206
6207 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
6208 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
6209 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
6210 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
6211 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
6212 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
6213 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6214 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
6215 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6216 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
6217 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6218 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6219 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6220 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6221
6222 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6223 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6224 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
6225 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6226 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
6227 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
6228 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
6229 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6230 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
6231 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6232 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6233 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6234 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6235 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6236
6237 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6238 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6239 xelectboardcardBvertex,yelectboardcardBvertex);
6240 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6241 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6242 + fgkEndCapInterfaceElectBoardCardBThickness);
6243 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6244 fSSDSupportRingAl);
6245 electboardcardB->SetLineColor(fColorAl);
6246 // Generating Stiffener 2
6247 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6248 0.5*fgkEndCapStiffenerThickness,
6249 0.5*fgkEndCapStiffenerLength);
6250 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6251 endcapstiffener->SetLineColor(fColorAl);
6252 // Generating Mother Interface Card B Container
6253 const Int_t kinterfacecardBmothervertexnumber = 10;
6254 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6255 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6256
6257 xinterfacecardBmothervertex[0] = 0.0;
6258 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6259 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6260 + fgkEndCapInterfaceCardBThickness;
6261 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6262 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6263 + fgkEndCapInterfaceElectBoardCardBThickness;
6264 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6265 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6266 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6267 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6268 + fgkEndCapCardJMDConnectorLength[0];
6269 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6270
6271 yinterfacecardBmothervertex[0] = 0.0;
6272 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6273 + fgkEndCapInterfaceCardBWidth[1]
6274 + fgkEndCapInterfaceCardBWidth[2];
6275 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6276 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6277 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6278 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6279 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6280 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6281 + fgkEndCapCardJMDConnectorWidth[0]
6282 + fgkEndCapCardJMDConnectorWidth[1];
6283 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6284 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6285 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6286 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6287 xinterfacecardBmothervertex,
6288 yinterfacecardBmothervertex);
6289 interfacecardBmothershape->DefineSection(0,-1.e-15);
6290 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6291 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6292 interfacecardBmothershape,fSSDAir);
6293 electboardcardB->SetLineColor(fColorAl);
6294 // Positioning Volumes Mother Interface Card B Container
6295 TGeoRotation* interfacecardBrot = new TGeoRotation();
6296 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6297 interfacecardBrot->SetAngles(90.,-90.,-90.);
6298 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6299 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6300 TGeoRotation* electboardcardBrot = new TGeoRotation();
6301 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6302 electboardcardBrot->SetAngles(90.,90.,-90.);
6303 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6304 TGeoCombiTrans* electboardcardBcombitrans =
6305 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6306 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6307 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6308 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6309 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6310 TGeoTranslation* jmdconnectorcardBtrans[3];
6311 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6312 for(Int_t i=0; i<3; i++){
6313 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6314 + fgkEndCapCardJMDConnectorLength[0],
6315 fgkEndCapCardElectBoardLayerWidth[1],
6316 0.5*fgkEndCapCardJMDConnectorThickness
6317 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6318 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6319 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6320 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6321 *jmdconnectorcardBrot);
6322 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6323 }
6324 // Mother Supply Card Container
6325 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6326 // Interface Card Container
6327 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6328 // Placing Volumes in Mother Supply Card Container
6329 // JMD Connector Positioning
6330 TGeoTranslation* jmdconnectortrans[2];
6331 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6332 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6333 fgkEndCapCardElectBoardBackLength[0]
6334 - fgkEndCapCardJMDConnectorThickness
6335 - fgkEndCapCardJMDConnectorToLayer);
6336 TGeoRotation* jmdconnectorot = new TGeoRotation();
6337 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6338 + 2.*fgkEndCapCardJMDConnectorLength[0]
6339 + 2.*fgkEndCapCardElectBoardLayerThickness,
6340 fgkEndCapCardElectBoardLayerWidth[1],
6341 fgkEndCapCardJMDConnectorThickness
6342 + fgkEndCapCardJMDConnectorToLayer);
6343 jmdconnectorot->SetAngles(90.,180.,-90);
6344 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6345 * jmdconnectorot);
6346 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6347 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6348 // Top Cable Connector Placing
6349 TGeoRotation* cableconnectorot[2];
6350 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6351 TGeoTranslation* cableconnectortrans[3];
6352 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6353 cableconnectorot[0]->SetAngles(90.,0.,0.);
6354 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6355 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6356 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6357 *cableconnectorot[0]);
6358 TGeoHMatrix* cableconnectormatrix[2];
6359 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6360 new TGeoHMatrix((*cableconnectorot[1])
6361 *(*cableconnectorcombitrans));
6362 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6363 - fgkEndCapCardCableConnectorThickness,
6364 fgkEndCapCardCableConnectorLength[0]
6365 + fgkEndCapCardCableConnectorToLayer);
6366 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6367 - 2.*fgkEndCapCardCableConnectorThickness
6368 - fgkEndCapCardCableConnectorDistance,
6369 fgkEndCapCardCableConnectorLength[0]
6370 + fgkEndCapCardCableConnectorToLayer);
6371 for(Int_t i=0; i<2; i++){
6372 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6373 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6374 }
6375 TGeoRotation* electboardbackrot = new TGeoRotation();
6376 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6377 electboardbackrot->SetAngles(90.,-90.,-90.);
6378 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6379 + fgkEndCapCardJMDConnectorLength[0]
6380 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6381 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6382 *electboardbackrot);
6383 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6384 // Electronic Board Kapton Layer Positioning
6385 TGeoRotation* electlayerrot = new TGeoRotation();
6386 TGeoTranslation* electlayertrans[2];
6387 TGeoCombiTrans* electlayercombitrans[2];
6388 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6389 electlayerrot->SetAngles(90.,-90.,-90.);
6390 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6391 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6392 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6393 + 2.*fgkEndCapCardElectBoardLayerThickness
6394 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6395 for(Int_t i=0; i<2; i++){
6396 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6397 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6398 }
6399 // Placing Volumes in Mother Interface Card Container
6400 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6401 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6402 for(Int_t i=0; i<2; i++){
6403 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6404 }
6405 /////////////////////////////////////////////////////////////
6406 // Generation of Card Interface Container
6407 /////////////////////////////////////////////////////////////
6408 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6409 - fgkEndCapCardJMDConnectorLength[0]
6410 - fgkEndCapInterfaceCardBThickness
6411 - 9.*fgkEndCapStripConnectionThickness
6412 - 8.*fgkEndCapCardElectBoardBackThickness;
6413 const Int_t kcardinterfacecontainervertexnumber = 14;
6414 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6415 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6416 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6417 - 7.0*fgkEndCapStripConnectionThickness;
6418 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6419 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6420 + fgkEndCapStripConnectionThickness
6421 - fgkEndCapCardElectBoardLayerThickness
6422 - fgkEndCapCardCableConnectorWidth[0];
6423 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6424 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6425 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6426 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6427 + 2.0*fgkEndCapStripConnectionThickness;
6428 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6429 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6430 + fgkEndCapInterfaceCardBThickness;
6431 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6432 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6433 + fgkEndCapInterfaceElectBoardCardBThickness;
6434 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6435 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6436 - fgkEndCapInterfaceElectBoardCardBThickness
6437 + fgkEndCapCardJMDConnectorLength[0]
6438 + stiffenertransx+fgkEndCapStiffenerWidth;
6439 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6440
6441 ycardinterfacecontainervertex[0] = 0.;
6442 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6443 + fgkEndCapCardJMDConnectorWidth[0]
6444 + fgkEndCapCardJMDConnectorWidth[1];
6445 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6446 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6447 - fgkEndCapStripConnectionWidth;
6448 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6449 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6450 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6451 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6452 + fgkEndCapInterfaceCardBWidth[1]
6453 + fgkEndCapInterfaceCardBWidth[2];
6454 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6455 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6456 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6457 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6458 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6459 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6460
6461 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6462 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6463 xcardinterfacecontainervertex,
6464 ycardinterfacecontainervertex);
6465 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6466 - fgkEndCapCardElectBoardBackLength[0]));
6467 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6468 + fgkEndCapCardElectBoardBackLength[0]));
6469 TGeoVolume** cardinterfacecontainer;
6470 cardinterfacecontainer = new TGeoVolume*[4];
6471 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6472 interfacecardmothershape,fSSDAir);
6473 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6474 interfacecardmothershape,fSSDAir);
6475 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6476 interfacecardmothershape,fSSDAir);
6477 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6478 interfacecardmothershape,fSSDAir);
6479 /////////////////////////////////
6480 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6481 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6482 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6483 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6484 /////////////////////////////////
6485 TGeoRotation* endcapstripconnectionrot[2];
6486 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6487 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6488 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6489 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6490 * (*endcapstripconnectionrot[0]));
6491 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6492 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6493 -0.5*fgkEndCapCardElectBoardBackThickness,
6494 fgkEndCapCardElectBoardBackWidth[0]
6495 -endcapstripconnectionshape->GetDZ(),
6496 0.5*fgkEndCapCardElectBoardBackLength[0]);
6497 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6498 TGeoTranslation* cardinterfacetrans[9];
6499 TGeoHMatrix* cardinterfacematrix[9];
6500 for(Int_t i=0; i<7; i++){
6501 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6502 + fgkEndCapCardElectBoardBackThickness),
6503 0.0,0.0);
6504 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6505 * (*endcapstripconnectionmatrix));
6506 }
6507 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6508 + fgkEndCapCardElectBoardBackThickness),
6509 0.0,0.0);
6510 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6511 * (*endcapstripconnectionmatrix));
6512 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6513 + fgkEndCapCardElectBoardBackThickness),
6514 0.0,0.0);
6515 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6516 * (*endcapstripconnectionmatrix));
6517
6518 for(Int_t i=0; i<4; i++){
6519 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6520 cardinterfacematrix[7]);
6521 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6522 cardinterfacematrix[8]);
6523 }
6524 TGeoTranslation* mothersupplycardtrans =
6525 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6526 + 2.*fgkEndCapCardJMDConnectorLength[0]
6527 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6528 TGeoHMatrix* mothersupplycardmatrix[7];
6529 Int_t index[4] = {1,1,1,1};
6530 for(Int_t i=0; i<7; i++){
6531 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6532 * (*mothersupplycardtrans));
6533 for(Int_t j=0; j<4; j++){
6534 switch(j){
6535 case 0: //Layer5 EndCap Left Side
6536 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6537 cardinterfacematrix[i]);
6538 if(i!=0){
6539 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6540 mothersupplycardmatrix[i]);
6541 index[j]++;
6542
6543 }
6544 break;
6545 case 1: //Layer5 EndCap Rigth Side
6546 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6547 cardinterfacematrix[i]);
6548 if(i>0&&i<6){
6549 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6550 mothersupplycardmatrix[i]);
6551 index[j]++;
6552 }
6553 break;
6554 case 2: //Layer6 EndCap Left Side
6555 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6556 cardinterfacematrix[i]);
6557 if(i!=6){
6558 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6559 mothersupplycardmatrix[i]);
6560 index[j]++;
6561 }
6562 break;
6563 case 3: //Layer6 EndCap Right Side
6564 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6565 cardinterfacematrix[i]);
6566 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6567 mothersupplycardmatrix[i]);
6568 index[j]++;
6569 break;
6570 }
6571 }
6572 }
6573 // Positioning Interface
6574 TGeoTranslation* motherinterfacecardtrans =
6575 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6576 +0.5*fgkEndCapCardElectBoardBackThickness
6577 -fgkEndCapCardElectBoardLayerThickness
6578 +fgkEndCapStripConnectionThickness,0.,0.);
6579 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6580 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6581 // Positioning Interface Card B
6582 TGeoTranslation* interfacecardBmothertrans =
6583 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6584 + 2.*fgkEndCapStripConnectionThickness
6585 + fgkEndCapCardElectBoardBackThickness,0.,
6586 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6587 - fgkEndCapCardElectBoardBackLength[0]));
6588 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6589 interfacecardBmothertrans);
6590 // Positioning Stiffener
6591 TGeoTranslation* endcapstiffenertrans =
6592 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6593 + 2.0*fgkEndCapStripConnectionThickness
6594 + fgkEndCapInterfaceCardBThickness
6595 + fgkEndCapCardJMDConnectorLength[0]
6596 + stiffenertransx
6597 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6598 endcapstiffenershape->GetDZ()
6599 - 0.5*(fgkEndCapStiffenerLength
6600 - fgkEndCapCardElectBoardBackLength[0]));
6601 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6602 /////////////////////////////////////////////////////////////
6603 // Deallocating memory
6604 /////////////////////////////////////////////////////////////
6605 delete interfacecardBrot;
6606 delete interfacecardBtrans;
6607 delete electboardcardBtrans;
6608 delete electboardcardBrot;
6609 delete jmdconnectorcardBrot;
6610 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6611 delete jmdconnectorot;
6612 delete jmdconnectortrans[1];
6613 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6614 delete cableconnectorcombitrans;
6615 delete electboardbacktrans;
6616 delete electboardbackrot;
6617 delete electlayerrot;
6618 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6619 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6620 delete mothersupplycardtrans;
6621 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6622 /////////////////////////////////////////////////////////////
6623 return cardinterfacecontainer;
6624 }
6625 ////////////////////////////////////////////////////////////////////////////////
6626 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6627 /////////////////////////////////////////////////////////////
6628 // Method returning EndCap Mother Volume
6629 /////////////////////////////////////////////////////////////
6630 const Int_t kendcapcoverplatesmallholenumber = 9;
6631 Double_t endcapmotherorigin[3];
6632 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6633 + 0.5 *(fgkEndCapCoverPlateLength[3]
6634 + 2.0 * fgkEndCapCoverPlateLength[2]);
6635 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6636 - fgkEndCapCoverPlateWidth[2]
6637 - (kendcapcoverplatesmallholenumber-1)
6638 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6639 + 0.5*(fgkEndCapSideCoverLength[2]
6640 + fgkEndCapCoverPlateWidth[1]
6641 - fgkEndCapCoverPlateWidth[0])
6642 - (fgkEndCapCoverPlateWidth[1]
6643 - fgkEndCapCoverPlateWidth[0]);
6644 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6645 + 2.*fgkEndCapCoolingTubeRadiusMax
6646 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6647 + fgkEndCapSideCoverWidth[1]
6648 + fgkEndCapSideCoverThickness
6649 + fgkEndCapKaptonFoilThickness);
6650 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6651 + 2.0* fgkEndCapCoverPlateLength[2]
6652 + 2.0* fgkEndCapSideCoverThickness),
6653 0.5* (fgkEndCapSideCoverLength[2]
6654 + fgkEndCapCoverPlateWidth[1]
6655 - fgkEndCapCoverPlateWidth[0]),
6656 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6657 + fgkEndCapSideCoverWidth[1]
6658 + fgkEndCapSideCoverThickness
6659 + fgkEndCapKaptonFoilThickness),
6660 endcapmotherorigin);
6661 TGeoVolume** endcapassembly;
6662 endcapassembly = new TGeoVolume*[4];
6663 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6664 endcapmothershape,fSSDAir);
6665 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6666 endcapmothershape,fSSDAir);
6667 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6668 endcapmothershape,fSSDAir);
6669 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6670 endcapmothershape,fSSDAir);
6671 /////////////////////////////////
6672 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6673 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6674 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6675 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6676 /////////////////////////////////
6677 /////////////////////////////////////////////////////
6678 // Placing Endcap Cover Plate
6679 /////////////////////////////////////////////////////
6680 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6681 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6682 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6683 TGeoCombiTrans* endcapcoverplatecombitrans =
6684 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6685 endcapcoverplaterot);
6686 TGeoTranslation* endcapcoverplatetrans =
6687 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6688 TGeoHMatrix* endcapcoverplatematrix =
6689 new TGeoHMatrix((*endcapcoverplatetrans)
6690 * (*endcapcoverplatecombitrans));
6691 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6692 /////////////////////////////////////////////////////
6693 // Placing Endcap Side Cover
6694 /////////////////////////////////////////////////////
6695 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6696 TGeoRotation* endcapsidecoverot[2];
6697 TGeoCombiTrans* endcapsidecovercombitrans[3];
6698 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6699 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6700 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6701 - 0.5*(fgkEndCapCoverPlateWidth[0]
6702 - fgkEndCapCoverPlateWidth[2]
6703 - (kendcapcoverplatesmallholenumber-1)
6704 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6705 + 0.*fgkEndCapCoverPlateWidth[0]
6706 + fgkEndCapSideCoverLength[2],
6707 0.5*(fgkEndCapSideCoverThickness
6708 + fgkEndCapCoverPlateThickness)
6709 - 0.5*fgkEndCapCoverPlateThickness,
6710 endcapsidecoverot[0]);
6711 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6712 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6713 0.5*fgkEndCapCoverPlateThickness
6714 -fgkEndCapSideCoverWidth[1],
6715 endcapsidecoverot[1]);
6716 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6717 +fgkEndCapCoverPlateLength[3]
6718 +2.*fgkEndCapCoverPlateLength[2]
6719 +fgkEndCapSideCoverThickness,0.0,
6720 0.5*fgkEndCapCoverPlateThickness
6721 -fgkEndCapSideCoverWidth[1],
6722 endcapsidecoverot[1]);
6723 TGeoHMatrix* endcapsidecovermatrix[2];
6724 for(Int_t i=0; i<2; i++){
6725 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6726 * (*endcapsidecovercombitrans[0]));
6727 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6728 endcapsidecovermatrix[i]);
6729 }
6730 /////////////////////////////////////////////////////
6731 // Placing Endcap Cooling Tube
6732 /////////////////////////////////////////////////////
6733 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6734 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6735 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6736 TGeoCombiTrans* endcapccolingtubecombitrans
6737 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6738 + fgkEndCapCoolingTubeAxialRadius[1])
6739 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6740 - fgkEndCapCoolingTubeToCoverSide,
6741 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6742 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6743 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6744 endcapccolingtubecombitrans);
6745 /////////////////////////////////////////////////////
6746 // Placing Screws
6747 /////////////////////////////////////////////////////
6748 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6749 fgkEndCapCoverPlateScrewRadiusMin};
6750 Int_t screwcoverplatedgesnumber[2] = {20,20};
6751 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6752 fgkEndCapCoverPlateThickness
6753 + fgkEndCapCoolingTubeRadiusMax};
851c0ce3 6754 TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
9b0c60ab 6755 screwcoverplatedgesnumber,
6756 screwcoverplatesection);
6757 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6758 screwcoverplateshape,
6759 fSSDCoolingTubePhynox);
6760 screwcoverplate->SetLineColor(12);
6761 Double_t transx[4] = {0,
6762 fgkEndCapCoverPlateSmallHoleSeparation[0],
6763 fgkEndCapCoverPlateSmallHoleSeparation[0]
6764 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6765 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6766 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6767 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6768// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6769 TGeoTranslation*** endcapcoverplatescrewtrans;
6770 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6771 Int_t index = 0;
6772 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6773 endcapcoverplatescrewtrans[i] =
6774 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6775 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6776 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6777 if(index==1||index==9||index==28||index==36){
6778 endcapcoverplatescrewtrans[i][j] =
6779 new TGeoTranslation(transx[i],
6780 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6781 fgkEndCapSideCoverThickness);
6782 }
6783 else{
6784 endcapcoverplatescrewtrans[i][j] =
6785 new TGeoTranslation(transx[i],
6786 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6787 0.);
6788 }
6789 if(index!=19)
6790 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6791 endcapcoverplatescrewtrans[i][j]);
6792 }
6793 }
6794 /////////////////////////////////////////////////////
6795 // Placing Cover Plate Clips
6796 /////////////////////////////////////////////////////
6797 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6798 0.5*fgkEndCapCoverPlateClipWidth,
6799 0.5*fgkEndCapSideCoverThickness);
6800 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6801 endcapcoverplateclipshape,
6802 fSSDCoolingTubePhynox);
6803 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6804 0.5*fgkEndCapCoverPlateDownClipWidth,
6805 0.5*fgkEndCapSideCoverThickness);
6806 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6807 endcapcoverplatedownclipshape,
6808 fSSDCoolingTubePhynox);
6809 TGeoTranslation* endcapcoverplatecliptrans[4];
6810 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6811 - fgkEndCapCoverPlateLength[0]
6812 - fgkEndCapSideCoverThickness,
6813 0.0,
6814 0.5*(fgkEndCapSideCoverThickness
6815 + fgkEndCapCoverPlateThickness));
6816 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6817 - fgkEndCapCoverPlateLength[0]
6818 - fgkEndCapSideCoverThickness,
6819 (kendcapcoverplatescrewnumber[1]-1)
6820 * fgkEndCapSideCoverWidth[5],
6821 0.5*(fgkEndCapSideCoverThickness
6822 + fgkEndCapCoverPlateThickness));
6823 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6824 - fgkEndCapCoverPlateLength[0]
6825 + fgkEndCapCoverPlateLength[1]
6826 + 2.*fgkEndCapCoverPlateLength[0]
6827 - fgkEndCapCoverPlateClipLength
6828 + fgkEndCapSideCoverThickness,
6829 0.0,
6830 0.5*(fgkEndCapSideCoverThickness
6831 + fgkEndCapCoverPlateThickness));
6832 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6833 - fgkEndCapCoverPlateLength[0]
6834 + fgkEndCapCoverPlateLength[1]
6835 + 2.*fgkEndCapCoverPlateLength[0]
6836 - fgkEndCapCoverPlateClipLength
6837 + fgkEndCapSideCoverThickness,
6838 (kendcapcoverplatescrewnumber[1]-1)
6839 * fgkEndCapSideCoverWidth[5],
6840 0.5*(fgkEndCapSideCoverThickness
6841 + fgkEndCapCoverPlateThickness));
6842 endcapcoverplateclip->SetLineColor(fColorPhynox);
6843 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6844 for(Int_t i=0; i<4; i++)
6845 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6846 endcapcoverplatecliptrans[i]);
6847 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6848 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6849 - fgkEndCapCoverPlateLength[0]
6850 - fgkEndCapSideCoverThickness,
6851 0.5*(fgkEndCapCoverPlateDownClipWidth
6852 - fgkEndCapCoverPlateClipWidth),
6853 0.5*(fgkEndCapSideCoverThickness
6854 + fgkEndCapCoverPlateThickness)
6855 - fgkEndCapSideCoverWidth[1]
6856 - fgkEndCapSideCoverThickness);
6857 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6858 - fgkEndCapCoverPlateLength[0]
6859 - fgkEndCapSideCoverThickness,
6860 0.5*(fgkEndCapCoverPlateDownClipWidth
6861 - fgkEndCapCoverPlateClipWidth)
6862 + fgkEndCapSideCoverLength[2]
6863 - fgkEndCapCoverPlateDownClipWidth,
6864 0.5*(fgkEndCapSideCoverThickness
6865 + fgkEndCapCoverPlateThickness)
6866 - fgkEndCapSideCoverWidth[1]
6867 - fgkEndCapSideCoverThickness);
6868 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6869 - fgkEndCapCoverPlateLength[0]
6870 + fgkEndCapSideCoverThickness
6871 + fgkEndCapCoverPlateLength[1]
6872 + 2.0*fgkEndCapCoverPlateLength[0]
6873 - fgkEndCapCoverPlateDownClipLength,
6874 0.5*(fgkEndCapCoverPlateDownClipWidth
6875 - fgkEndCapCoverPlateClipWidth),
6876 0.5*(fgkEndCapSideCoverThickness
6877 + fgkEndCapCoverPlateThickness)
6878 - fgkEndCapSideCoverWidth[1]
6879 - fgkEndCapSideCoverThickness);
6880 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6881 - fgkEndCapCoverPlateLength[0]
6882 + fgkEndCapSideCoverThickness
6883 + fgkEndCapCoverPlateLength[1]
6884 + 2.0*fgkEndCapCoverPlateLength[0]
6885 - fgkEndCapCoverPlateDownClipLength,
6886 0.5*(fgkEndCapCoverPlateDownClipWidth
6887 - fgkEndCapCoverPlateClipWidth)
6888 + fgkEndCapSideCoverLength[2]
6889 - fgkEndCapCoverPlateDownClipWidth,
6890 0.5*(fgkEndCapSideCoverThickness
6891 + fgkEndCapCoverPlateThickness)
6892 - fgkEndCapSideCoverWidth[1]
6893 - fgkEndCapSideCoverThickness);
6894 for(Int_t i=0; i<4; i++)
6895 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6896 endcapcoverplatedowncliptrans[i]);
6897 /////////////////////////////////////////////////////
6898 // Placing Kapton Foil
6899 /////////////////////////////////////////////////////
6900 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6901 0.5*fgkEndCapKaptonFoilWidth,
6902 0.5*fgkEndCapKaptonFoilThickness);
6903 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6904 endcapkaptonfoilshape,
6905 fSSDKaptonFlexMedium);
6906 endcapkaptonfoil->SetLineColor(8);
6907 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6908 0.5*fgkEndCapKaptonFoilWidth
6909 - 0.5*fgkEndCapCoverPlateClipWidth,
6910 0.5*fgkEndCapCoverPlateThickness
6911 - 0.5*fgkEndCapKaptonFoilThickness
6912 - fgkEndCapSideCoverWidth[1]
6913 - fgkEndCapSideCoverThickness);
6914 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6915 /////////////////////////////////////////////////////////////
6916 // Placing Electronic Tubes
6917 /////////////////////////////////////////////////////////////
6918 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6919 - fgkEndCapInterfaceCardBThickness
6920 - 9.*fgkEndCapStripConnectionThickness
6921 - 8.*fgkEndCapCardElectBoardBackThickness,
6922 fgkEndCapKaptonFoilWidth
6923 - fgkEndCapInterfaceCardBThickness
6924 - 9.*fgkEndCapStripConnectionThickness
6925 - 8.*fgkEndCapCardElectBoardBackThickness
6926 - fgkEndCapInterfaceElectBoardCardBThickness};
6927 TGeoVolume* endcapeffectivecables[2];
6928 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6929 fgkEndCapEffectiveCableRadiusMax,
6930 endcapeffectivecableswidth[0],
6931 10,"EndCapEffectiveCables1");
6932 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6933 fgkEndCapEffectiveCableRadiusMax,
6934 endcapeffectivecableswidth[1],
6935 25,"EndCapEffectiveCables2");
6936 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6937 TGeoTranslation* endcapeffectivecablestrans[2];
6938 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6939 - 0.5*endcapeffectivecableswidth[0]
6940 - 0.5*(fgkEndCapCoverPlateWidth[0]
6941 - fgkEndCapCoverPlateWidth[2]
6942 - (kendcapcoverplatesmallholenumber-1)
6943 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6944 + fgkEndCapSideCoverLength[2],
6945 - 0.5*fgkEndCapCoverPlateThickness
6946 - (fgkEndCapCardElectBoardBackWidth[0]
6947 - fgkEndCapInterfaceCardBWidth[0]
6948 - fgkEndCapInterfaceCardBWidth[1]));
6949 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6950 - 0.5*endcapeffectivecableswidth[1]
6951 - 0.5*(fgkEndCapCoverPlateWidth[0]
6952 - fgkEndCapCoverPlateWidth[2]
6953 - (kendcapcoverplatesmallholenumber-1)
6954 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6955 + fgkEndCapSideCoverLength[2],
6956 - 0.5*fgkEndCapCoverPlateThickness
6957 - (fgkEndCapCardElectBoardBackWidth[0]
6958 - fgkEndCapInterfaceCardBWidth[0])
6959 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6960 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6961 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6962 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6963 *endcapeffectivecablesrot);
6964 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6965 *endcapeffectivecablesrot);
47f8de53 6966// for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6967// endcapeffectivecablescombitrans[0]);
9b0c60ab 6968 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6969 endcapeffectivecablescombitrans[1]);
6970 /////////////////////////////////////////////////////////////
6971 // Placing End Cap Cards
6972 /////////////////////////////////////////////////////////////
6973 TGeoVolume** endcapcards = GetEndCapCards();
6974 TGeoRotation* endcapcardsrot[2];
6975 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6976 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6977 TGeoTranslation* endcapcardstrans[2];
6978 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6979 - fgkEndCapCardElectBoardBackLength[0]));
6980 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6981 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6982 TGeoHMatrix* endcapcardsmatrix[2];
6983 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6984 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6985 - fgkEndCapCardJMDConnectorLength[0]
6986 - fgkEndCapInterfaceCardBThickness
6987 - 9.*fgkEndCapStripConnectionThickness
6988 - 8.*fgkEndCapCardElectBoardBackThickness;
6989 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6990 - fgkEndCapCoverPlateLength[0]
6991 + 0.5 * (fgkEndCapCoverPlateLength[3]
6992 + 2.0 * fgkEndCapCoverPlateLength[2]),
6993 - stiffenertransx-fgkEndCapStiffenerWidth
6994 - fgkEndCapCardJMDConnectorLength[0]
6995 - fgkEndCapInterfaceCardBThickness
6996 - 2.0 * fgkEndCapStripConnectionThickness
6997 - 1.5 * fgkEndCapInterfaceCardBThickness
6998 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6999 - fgkEndCapCoverPlateWidth[2]
7000 - (kendcapcoverplatesmallholenumber-1)
7001 * fgkEndCapCoverPlateSmallHoleSeparation[2])
7002 + fgkEndCapKaptonFoilWidth,
7003 0.5*fgkEndCapCoverPlateThickness
7004 - fgkEndCapSideCoverWidth[1]);
7005 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
7006 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
7007 /////////////////////////////////////////////////////////////
7008 // Deallocating memory
7009 /////////////////////////////////////////////////////////////
7010 delete endcapcoverplaterot;
7011 delete endcapcoverplatecombitrans;
7012 delete endcapcoverplatetrans;
7013 for(Int_t i=0; i<3; i++){
7014 delete endcapsidecovercombitrans[i];
7015 if(i<2) delete endcapsidecoverot[i];
7016 }
7017 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
7018 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
7019 delete endcapcardsmatrix[0];
7020 return endcapassembly;
7021 }
7022 ////////////////////////////////////////////////////////////////////////////////
7023 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
7024 Double_t radiusmax,
7025 Double_t width,
7026 Int_t ncables,
a6e0ebfe 7027 const char* volname){
9b0c60ab 7028 /////////////////////////////////////////////////////////////
7029 // Generating EndCap High Voltage Tubes
7030 /////////////////////////////////////////////////////////////
7031 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
7032 Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.)
7033 + TMath::Power(radiusmax,2.)
7034 - TMath::Power(radiusmin,2.));
7035 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
7036 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
7037 effectiveouteradius,0.5*width);
7038 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
7039 effectiveinnertubeshape,
7040 fSSDStiffenerConnectorMedium);
7041 effectiveinnertube->SetLineColor(41);
7042 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
7043 effectiveoutertubeshape,
7044 fSSDKaptonChipCableMedium);
7045 effectiveoutertube->SetLineColor(39);
7046 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
7047 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
7048 effectivemothertube->AddNode(effectiveinnertube,1);
7049 effectivemothertube->AddNode(effectiveoutertube,1);
7050 return effectivemothertube;
7051 }
7052 ////////////////////////////////////////////////////////////////////////////////
7053 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
7054 /////////////////////////////////////////////////////////////
7055 // Generating EndCap Support Layer 5 and Layer 6
7056 /////////////////////////////////////////////////////////////
7057 const Int_t knedges = 5;
7058 ///////////////////////////////////////////////
7059 // Setting the vertices for TGeoXtru Up Volume
7060 ///////////////////////////////////////////////
7061 const Int_t klayernumber = 2;
7062 Double_t xupvertex[klayernumber][knedges+3];
7063 Double_t yupvertex[klayernumber][knedges+3];
7064 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
7065 Double_t middledgeangle[klayernumber] = {0.0,0.0};
7066 Double_t middlepsi[klayernumber] = {0.0,0.0};
7067 for(Int_t i=0; i<klayernumber; i++){
7068 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
7069 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
7070 xupvertex[i][2] = -xupvertex[i][1];
7071 xupvertex[i][3] = -xupvertex[i][0];
7072
7073 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
7074 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
7075 yupvertex[i][2] = yupvertex[i][1];
7076 yupvertex[i][3] = yupvertex[i][0];
7077
7078 middledgeangle[i] = upedgeangle[i]/knedges;
7079 middlepsi[i] = 90.0-0.5*upedgeangle[i];
7080 for(Int_t j=1; j<knedges; j++){
7081 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
7082 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
7083 }
7084 }
7085 ////////////////////////////////////
7086 // Generating Up TGeoXtru
7087 ////////////////////////////////////
7088 TGeoXtru* upendcapsupportshape[klayernumber];
7089 TGeoVolume* upendcapsupport[klayernumber];
a3f8715e 7090 char upendcapsupportname[100];
9b0c60ab 7091 for(Int_t i=0; i<klayernumber; i++){
7092 upendcapsupportshape[i] = new TGeoXtru(2);
7093 sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
7094 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
7095 upendcapsupportshape[i]->DefineSection(0,0.);
7096 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
7097 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 7098 fSSDSupportRingAl);
9b0c60ab 7099 upendcapsupport[i]->SetLineColor(5);
7100 }
7101 ///////////////////////////////////////////////
7102 // Setting the vertices for TGeoXtru Down Volume
7103 ///////////////////////////////////////////////
7104 Double_t xdownvertex[klayernumber][2*(knedges+1)];
7105 Double_t ydownvertex[klayernumber][2*(knedges+1)];
7106 for(Int_t i=0; i<klayernumber; i++){
7107 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
7108 xdownvertex[i][1] = xupvertex[i][0];
7109 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
7110 ydownvertex[i][1] = yupvertex[i][0];
7111 for(Int_t j=0; j<knedges; j++){
7112 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
7113 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
7114 }
7115 for(Int_t j=0; j<knedges; j++){
7116 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
7117 * CosD(middlepsi[i]+j*middledgeangle[i]);
7118 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
7119 * SinD(middlepsi[i]+j*middledgeangle[i]);
7120 }
7121 }
7122 ////////////////////////////////////
7123 // Generating Down TGeoXtru
7124 ////////////////////////////////////
7125 TGeoXtru* downendcapsupportshape[klayernumber];
7126 TGeoVolume* downendcapsupport[klayernumber];
a3f8715e 7127 char downendcapsupportname[100];
9b0c60ab 7128 for(Int_t i=0; i<klayernumber; i++){
7129 downendcapsupportshape[i] = new TGeoXtru(2);
7130 sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
7131 downendcapsupportshape[i] = new TGeoXtru(2);
7132 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
7133 if(i==0){
7134 downendcapsupportshape[i]->DefineSection(0,0.);
7135 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
7136 }
7137 else{
7138 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
7139 - fgkEndCapSupportLowWidth[i]);
7140 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
7141 }
7142 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 7143 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 7144 downendcapsupport[i]->SetLineColor(5);
7145 }
7146 ///////////////////////////////////////////////
7147 // Setting TGeoPgon Volume
7148 ///////////////////////////////////////////////
7149 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
7150 fgkSSDLay6LadderNumber};
7151 TGeoPgon* endcapsupportmothershape[klayernumber];
7152 TGeoVolume** endcapsupportmother;
7153 endcapsupportmother = new TGeoVolume*[klayernumber];
a3f8715e 7154 char endcapsupportmothername[100];
9b0c60ab 7155 for(Int_t i=0; i<klayernumber; i++){
7156 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7157 sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
7158 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
7159 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
7160 ydownvertex[i][0],yupvertex[i][1]);
7161 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 7162 fSSDAir);
9b0c60ab 7163 }
7164 ////////////////////////////////////
7165 TGeoRotation** endcapsupportrot[klayernumber];
7166 for(Int_t i=0; i<2; i++){
7167 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
7168 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7169 endcapsupportrot[i][j] = new TGeoRotation();
7170 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
7171 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
7172 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
7173 }
7174 }
7175 return endcapsupportmother;
7176 }
7177 ////////////////////////////////////////////////////////////////////////////////
7178 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
7179 /////////////////////////////////////////////////////////////
7180 // Setting End Cap Support Layer 5 and 6.
7181 /////////////////////////////////////////////////////////////
7182 const Int_t kendcapcoverplatesmallholenumber = 9;
7183 const Int_t klayernumber = 2;
7184 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
7185 fgkSSDLay6LadderNumber};
7186 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
7187 360.0/kssdlayladdernumber[1]};
7188 TGeoVolume** endcapsupport = EndCapSupport();
7189 TGeoVolume** endcapassembly = GetEndCapAssembly();
7190 TGeoPgon* endcapsupportshape[klayernumber];
7191 Double_t* radiusmin[klayernumber];
7192 Double_t* radiusmax[klayernumber];
7193 for(Int_t i=0; i<klayernumber; i++){
7194 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
7195 radiusmin[i] = endcapsupportshape[i]->GetRmin();
7196 radiusmax[i] = endcapsupportshape[i]->GetRmax();
7197 }
7198 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
7199 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
7200 endcapassemblyshape->GetDY(),
7201 endcapassemblyshape->GetDZ()};
7202 ///////////////////////////////////////////////
7203 // Setting TGeoPgon Volume for Mother Container
7204 ///////////////////////////////////////////////
7205 TGeoPgon* endcapsupportsystemshape[klayernumber];
a3f8715e 7206 char endcapsupportsystemothername[100];
9b0c60ab 7207 for(Int_t i=0; i<klayernumber; i++){
7208 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7209 sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
7210 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
7211 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
7212 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7213 +2.*endcapassemblycenter[2])
7214 /CosD(0.5*upedgeangle[i]));
7215 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7216 -(fgkEndCapCoverPlateWidth[1]
7217 - fgkEndCapCoverPlateWidth[0]),
7218 *radiusmin[i],
7219 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7220 +2.*endcapassemblycenter[2])
7221 /CosD(0.5*upedgeangle[i]));
7222 }
e5bf64ae 7223 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 7224 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7225 endcapsupportsystemshape[0],fSSDAir);
7226 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7227 endcapsupportsystemshape[0],fSSDAir);
7228 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7229 endcapsupportsystemshape[1],fSSDAir);
7230 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7231 endcapsupportsystemshape[1],fSSDAir);
7232 ///////////////////////////////////////////////
7233 TGeoTranslation* endcapassemblytrans[klayernumber];
7234 for(Int_t i=0; i<klayernumber; i++)
7235 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7236 - fgkEndCapSideCoverThickness
7237 + endcapassemblycenter[0],
7238 - 0.5*fgkEndCapCoverPlateThickness
7239 - 2.0*fgkEndCapCoolingTubeRadiusMax
7240 + 2.0*endcapassemblycenter[2]
7241 + 0.5*fgkEndCapSupportLength[i]
7242 / TanD(0.5*upedgeangle[i]),
7243 0.5*(fgkEndCapCoverPlateWidth[0]
7244 - fgkEndCapCoverPlateWidth[2]
7245 - (kendcapcoverplatesmallholenumber-1)
7246 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
7247 TGeoRotation** endcapassemblyrot[klayernumber];
7248 TGeoHMatrix** endcapassemblymatrix[klayernumber];
7249 for(Int_t i=0; i<klayernumber; i++){
7250 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7251 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7252 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7253 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7254 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7255 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7256 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7257 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7258 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7259 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7260 }
7261 }
7262 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7263 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7264 for(Int_t i=0; i<2*klayernumber; i++){
7265 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7266 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7267 endcapassemblymatrix[1][j+2]);
7268 }
7269 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7270 }
7271 /////////////////////////////////////////////////////////////
7272 // Deallocating memory
7273 /////////////////////////////////////////////////////////////
7274 for(Int_t i=0; i<klayernumber; i++){
7275 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7276 delete endcapassemblyrot[i][j];
7277 }
7278 delete endcapassemblyrot[i];
7279 delete endcapassemblymatrix[i][0];
7280 delete endcapassemblymatrix[i][1];
7281 }
7282 /////////////////////////////////////////////////////////////
7283 }
7284 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7285 /////////////////////////////////////////////////////////////
7286 // Setting End Cap Support + End Cap Assembly of Layer 5.
7287 /////////////////////////////////////////////////////////////
7288 if (! moth) {
7289 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, mother is null!\n");
7290 return;
7291 };
e5bf64ae 7292 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7293 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7294 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7295 fgkEndCapSupportCenterLay5ITSPosition
7296 + fgkEndCapSupportCenterLay5Position
7297 - fgkEndCapSideCoverLength[2]);
7298 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7299 fgkEndCapSideCoverLength[2]
7300 - fgkEndCapSupportCenterLay5Position
7301 - fgkEndCapSupportCenterLay5ITSPosition);
7302 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7303 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7304 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7305 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7306 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7307 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7308 /////////////////////////////////////////////////////////////
7309 // Deallocating memory
7310 /////////////////////////////////////////////////////////////
7311 delete endcapsupportsystemrot;
7312 delete endcapsupportsystemITSCentertrans[1];
7313 }
7314 /////////////////////////////////////////////////////////////
7315 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7316 /////////////////////////////////////////////////////////////
7317 // Setting End Cap Support + End Cap Assembly of Layer 6.
7318 /////////////////////////////////////////////////////////////
7319 if (! moth) {
7320 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
7321 return;
7322 };
e5bf64ae 7323 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7324 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7325 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7326 fgkEndCapSupportCenterLay6ITSPosition
7327 + fgkEndCapSupportCenterLay6Position
7328 - fgkEndCapSideCoverLength[2]);
7329 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7330 fgkEndCapSideCoverLength[2]
7331 - fgkEndCapSupportCenterLay6Position
7332 - fgkEndCapSupportCenterLay6ITSPosition);
7333 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7334 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7335 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7336 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7337 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7338 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7339 /////////////////////////////////////////////////////////////
7340 // Deallocating memory
7341 /////////////////////////////////////////////////////////////
7342 delete endcapsupportsystemrot;
7343 delete endcapsupportsystemITSCentertrans[1];
7344 }
7345 ////////////////////////////////////////////////////////////////////////////////
7346 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7347 /////////////////////////////////////////////////////////////
7348 // Setting Ladder Support of Layer 5.
7349 /////////////////////////////////////////////////////////////
7350 if (! moth) {
7351 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
7352 return;
7353 };
7354 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7355 fMotherVol = moth;
7356 TGeoTranslation* centerITSRingSupportLay5trans[2];
7357 for(Int_t i=0; i<2; i++){
7358 centerITSRingSupportLay5trans[i] =
7359 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7360 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7361 }
7362 }
7363 ////////////////////////////////////////////////////////////////////////////////
7364 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7365 /////////////////////////////////////////////////////////////
7366 // Setting Ladder Support of Layer 6.
7367 /////////////////////////////////////////////////////////////
7368 if (! moth) {
7369 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
7370 return;
7371 };
7372 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7373 fMotherVol = moth;
7374 TGeoTranslation* centerITSRingSupportLay6trans[2];
7375 for(Int_t i=0; i<2; i++){
7376 centerITSRingSupportLay6trans[i] =
7377 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7378 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7379 }
7380 }
7381 ////////////////////////////////////////////////////////////////////////////////
47f8de53 7382 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7383 /////////////////////////////////////////////////////////////
7384 // Setting Ladder Support of Layer 6.
7385 /////////////////////////////////////////////////////////////
7386 if (! moth) {
7387 printf("Error::AliITSv11GeometrySSD: Can't insert SSD Cone, mother is null!\n");
7388 return;
7389 };
7390 if(!fSSDCone) SetSSDCone();
7391 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7392 + fgkSSDCentralAL3SupportLength);
7393 moth->AddNode(fSSDCone,1,ssdconetrans);
7394}
7395 ////////////////////////////////////////////////////////////////////////////////
7396 void AliITSv11GeometrySSD::SetSSDCone(){
7397 /////////////////////////////////////////////////////////////
7398 // Method generating SSDCone
7399 /////////////////////////////////////////////////////////////
7400 if(!fCreateMaterials) CreateMaterials();
7401 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7402 Double_t ssdpconesectionradiusmax[16];
7403 Double_t ssdpconesectionradiusmin[16];
7404 Double_t ssdpconezsection[16];
7405 TGeoPcon* ssdpconelittleholeshape[8];
7406 TGeoVolume* ssdpconelittlehole[8];
7407 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7408 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7409 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7410 / SinD(fgkSSDPConeAngle)
7411 + ssdpconesectionradiusmin[0];
7412 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7413 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7414 / SinD(fgkSSDPConeAngle);
7415 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7416 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7417 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7418 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7419 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7420 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7421 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7422 ssdpconelittlehole[0]->SetLineColor(4);
7423 /////////////////////////////////////////////////////////////
7424 ssdpconezsection[2] = ssdpconezsection[1];
7425 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7426 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7427 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7428 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7429 / SinD(fgkSSDPConeAngle);
7430 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7431 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7432 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7433 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7434 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7435 * TMath::RadToDeg();
7436 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7437 60.-ssdpconelittleholeangle,2);
7438 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7439 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7440 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7441 ssdpconelittlehole[1]->SetLineColor(4);
7442 TGeoRotation* ssdconelittleholerot[6];
7443 for(Int_t i=0; i<6; i++){
7444 ssdconelittleholerot[i] = new TGeoRotation();
7445 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7446 }
7447 /////////////////////////////////////////////////////////////
7448 ssdpconezsection[4] = ssdpconezsection[3];
7449 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7450 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7451 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7452 * CosD(fgkSSDPConeAngle)
7453 / SinD(fgkSSDPConeAngle);
7454 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7455 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7456 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7457 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7458 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7459 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7460 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7461 ssdpconelittlehole[2]->SetLineColor(4);
7462 ///////////////////////////////////////////////////
7463 ssdpconezsection[6] = ssdpconezsection[5];
7464 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7465 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7466 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7467 -ssdpconezsection[0]
7468 * CosD(fgkSSDPConeAngle)
7469 / SinD(fgkSSDPConeAngle);
7470 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7471 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7472 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7473 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7474 * TMath::RadToDeg();
7475 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7476 45.-ssdpconemiddleholeangle,2);
7477 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7478 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7479 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7480 ssdpconelittlehole[3]->SetLineColor(4);
7481 TGeoRotation* ssdconemiddleholerot[8];
7482 for(Int_t i=0; i<8; i++){
7483 ssdconemiddleholerot[i] = new TGeoRotation();
7484 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7485 }
7486 /////////////////////////////////////////////////////////////
7487 ssdpconezsection[8] = ssdpconezsection[7];
7488 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7489 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7490 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7491 * CosD(fgkSSDPConeAngle)
7492 / SinD(fgkSSDPConeAngle);
7493 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7494 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7495 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7496 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7497 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7498 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7499 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7500 ssdpconelittlehole[4]->SetLineColor(4);
7501 /////////////////////////////////////////////////////////////
7502 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7503 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7504 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7505 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7506 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7507 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7508 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7509 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7510 * TMath::RadToDeg();
7511 ssdpconezsection[10] = ssdpconezsection[9];
7512 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7513 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7514 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7515 * CosD(fgkSSDPConeAngle)
7516 / SinD(fgkSSDPConeAngle);
7517 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7518 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7519 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7520 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7521 ssdpconetrapezoidsectionangle,2);
7522 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7523 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7524 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7525 ssdpconelittlehole[5]->SetLineColor(4);
7526 TGeoRotation* ssdconeupradiusrot[8];
7527 for(Int_t i=0; i<8; i++){
7528 ssdconeupradiusrot[i] = new TGeoRotation();
7529 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7530 }
7531 /////////////////////////////////////////////////////////////
7532 ssdpconezsection[12] = ssdpconezsection[11];
7533 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7534 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7535 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7536 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7537 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7538 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7539 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7540 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7541 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7542 ssdpconelittlehole[6]->SetLineColor(4);
7543 /////////////////////////////////////////////////////////////
7544 ssdpconezsection[14] = 0.0;
7545 ssdpconezsection[15] = ssdpconezsection[0];
7546 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7547 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7548 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7549 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7550 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7551 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7552 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7553 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7554 ssdpconelittlehole[7]->SetLineColor(4);
7555 /////////////////////////////////////////////////////////////
7556 TGeoTube* ssdtubeconeshape[2];
7557 TGeoVolume* ssdtubecone[2];
7558 TGeoTranslation* ssdtubeconetrans[2];
7559 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7560 fgkSSDPConeExternalRadius,
7561 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7562 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7563 0.5*ssdpconezsection[0]);
7564 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7565 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7566 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7567 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7568 + ssdpconezsection[13]);
7569 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7570 ssdtubecone[0]->SetLineColor(4);
7571 ssdtubecone[1]->SetLineColor(4);
7572 /////////////////////////////////////////////////////////////
7573 // Mother Volume Container
7574 /////////////////////////////////////////////////////////////
7575 Double_t ssdconemotherradiusmin[8];
7576 Double_t ssdconemotherradiusmax[8];
7577 Double_t ssdconemothersection[8];
7578 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7579 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7580 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7581 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7582 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7583 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7584 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7585 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7586 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7587 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7588 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7589 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7590 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7591 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7592 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7593 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7594 ssdconemothersection[0] = 0.0;
7595 ssdconemothersection[1] = ssdpconezsection[0];
7596 ssdconemothersection[2] = ssdpconezsection[0];
7597 ssdconemothersection[3] = ssdpconezsection[11];
7598 ssdconemothersection[4] = ssdpconezsection[11];
7599 ssdconemothersection[5] = ssdpconezsection[13];
7600 ssdconemothersection[6] = ssdpconezsection[13];
7601 ssdconemothersection[7] = fgkSSDPConeLength;
7602 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7603 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7604 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7605 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7606 /////////////////////////////////////////////////////////////
7607 //Placing the Volumes into Mother
7608 /////////////////////////////////////////////////////////////
7609 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7610 for(Int_t i=0; i<6; i++){
7611 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7612 }
7613 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7614 for(Int_t i=0; i<8; i++){
7615 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7616 }
7617 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7618 for(Int_t i=0; i<8; i++){
7619 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7620 }
7621 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7622 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7623 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7624 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7625 /////////////////////////////////////////////////////////////
7626 // ITS General Support
7627 /////////////////////////////////////////////////////////////
7628 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7629 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7630 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7631 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7632 - fgkSSDCentralAL3SupportLength);
7633 ssdcentralsupport->SetLineColor(4);
7634 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7635 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7636 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7637 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7638 TGeoTranslation* ssdcentralal3supportrans[3];
7639 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7640 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7641 - 1.25*fgkSSDCentralAL3SupportLength);
7642 ssdcentralal3support->SetLineColor(4);
7643 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7644 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7645 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7646 Double_t ssdpconcentralradiusmin[2];
7647 Double_t ssdpconcentralradiusmax[2];
7648 Double_t ssdpconcentralsection[2];
7649 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7650 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7651 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7652 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7653 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7654 ssdpconcentralsection[1] = 0.;
7655 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7656 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7657 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7658 ssdpconcentralal3->SetLineColor(4);
7659 fSSDCone->AddNode(ssdpconcentralal3,1);
7660 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7661 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7662 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7663 -2.*fgkSSDCentralAL3SupportLength);
7664 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7665 *ssdcentralal3supportrot);
7666 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7667 TGeoRotation* ssdconemotherot = new TGeoRotation();
7668 ssdconemotherot->SetAngles(90.,180.,-90.);
7669 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7670 -2.*fgkSSDCentralAL3SupportLength);
7671 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7672 fSSDCone->AddNode(ssdconemother,1);
7673 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7674 /////////////////////////////////////////////////////////////
7675 // Deallocating memory
7676 /////////////////////////////////////////////////////////////
7677 delete ssdcentralal3supportrot;
7678 delete ssdcentralal3supportrans[2];
7679 delete ssdconemotherot;
7680 delete ssdconemothertrans;
7681 /////////////////////////////////////////////////////////////
7682 }
fcfbdd23 7683 ////////////////////////////////////////////////////////////////////////////////
7684 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7685 /////////////////////////////////////////////////////////////
7686 // Setting SSD Cables
7687 /////////////////////////////////////////////////////////////
7688 if (! moth) {
7689 printf("Error::AliITSv11GeometrySSD: Can't insert SSD Cables, mother is null!\n");
7690 return;
7691 };
7692 TGeoVolume* ssdcables = SetSSDCables();
7693 moth->AddNode(ssdcables,1);
7694}
47f8de53 7695 ////////////////////////////////////////////////////////////////////////////////
7696 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7697 /////////////////////////////////////////////////////////////
7698 // Method generating SSDCables
7699 /////////////////////////////////////////////////////////////
7700 // SSD Layer 5 Cables
7701 //////////////////////////////////////////////////////////////////////////////////////////////////
7702 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7703 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
fcfbdd23 7704 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
47f8de53 7705 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7706 //////////////////////////////////////////////////////////////////////////////////////////////////
7707 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+fgkSSDCablesLay5TubeRadiusMin;
7708 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7709 - fgkSSDLowerPConeRadius)
7710 * TanD(fgkSSDPConeAngle);
7711 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7712 + fgkEndCapSupportCenterLay5Position
7713 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7714 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7715 - ssdcableslay5startconedistance;
7716 ssdcablelay5rightsidelength *= ssdcablesfactor;
7717 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+fgkSSDCablesLay5RightSideHeight;
7718 TGeoTube* ssdcablelay5rightubeshape = new TGeoTube(ssdcableslay5rigthsideradiusmin,
7719 ssdcableslay5rightsideradiusmax,
7720 0.5*ssdcablelay5rightsidelength);
7721 TGeoVolume* ssdcablelay5righttube = new TGeoVolume("SSDCableLay5RightSideTube",
7722 ssdcablelay5rightubeshape,
7723 fSSDCopper);
7724 ssdcablelay5righttube->SetLineColor(9);
7725 TGeoTranslation* ssdcablelay5rightrans =
7726 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7727 + fgkEndCapSupportCenterLay5Position
7728 + 0.5*ssdcablelay5rightsidelength);
7729 ////////////////////////////////////
7730 // Double_t cablescapacity[20];
7731 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7732 ////////////////////////////////////
7733 ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7734 ////////////////////////////////////
7735 // TGeoPCone Volumes
7736 ///////////////////////////////////
7737 TGeoPcon* ssdcableslay5pconshape[3];
7738 TGeoVolume* ssdcableslay5pcon[3];
7739 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7740 Double_t ssdcableslay5pconzsection[6];
7741 Double_t ssdcableslay5pconrmin[6];
7742 Double_t ssdcableslay5pconrmax[6];
7743 ssdcableslay5pconrmin[0] = ssdcablelay5rightubeshape->GetRmin();
7744 ssdcableslay5pconrmax[0] = ssdcablelay5rightubeshape->GetRmax();
7745 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7746 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+fgkSSDCablesLay5RightSideHeight;
7747 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7748 + fgkEndCapSupportCenterLay5Position
7749 + 2.*ssdcablelay5rightubeshape->GetDz();
7750 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7751 + fgkSSDCentralAL3SupportLength
7752 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7753 * TanD(fgkSSDPConeAngle);
7754 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7755 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7756 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7757 ssdcableslay5pconshape[0],fSSDCopper);
7758 ssdcableslay5pcon[0]->SetLineColor(9);
7759 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7760////////////////////////////////////
7761// cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7762////////////////////////////////////
7763 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7764 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7765 + fgkSSDCentralAL3SupportLength
7766 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7767 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7768 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7769 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7770 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7771 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7772 ssdcableangle,2);
7773 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7774 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7775 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7776 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7777 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7778 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3]+fgkSSDCablesLay5RightSideHeight;
7779 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7780 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7781 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7782 ssdcableslay5pcon[1]->SetLineColor(9);
7783 ////////////////////////////////////
7784 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7785 ssdcableangle,2);
7786 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7787 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7788 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7789 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7790 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7791 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7792 * TanD(fgkSSDPConeAngle)
7793 + 0.5*fgkSSDCentralSupportLength
7794 + fgkSSDCentralAL3SupportLength;
7795 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7796 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7797 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7798 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7799 ssdcableslay5pcon[2]->SetLineColor(9);
7800////////////////////////////////////
7801 TGeoRotation* ssdcableslay5pconrot[4];
7802 for(Int_t i=0; i<4; i++){
7803 ssdcableslay5pconrot[i] = new TGeoRotation();
7804 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7805 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7806 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
7807 }
7808 ////////////////////////////////////
7809 //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7810 //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7811 ////////////////////////////////////
7812 // Positioning Left SSD Cables Part
7813 ////////////////////////////////////
7814 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7815 - 0.5*ssdcablelay5rightsidelength
7816 - fgkEndCapSupportCenterLay5Position
7817 - fgkEndCapSupportCenterLay5ITSPosition);
7818 ssdcablesmother->AddNode(ssdcablelay5righttube,2,ssdcablesLay5RightTubeToLeftrans);
7819 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7820 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7821 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7822 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7823 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7824 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7825 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7826 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7827 }
7828 ////////////////////////////////////
7829 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7830 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7831 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7832 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7833 /////////////////////////////////////////////////////////////
7834 // Water Tubes Layer 5
7835 /////////////////////////
7836 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7837 ssdcableslay5rightsideradiusmax
7838 + fgkSSDCablesLay5RightSideWaterHeight,
7839 0.5*ssdcablelay5rightsidelength);
7840 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7841 ssdcablelay5rightubewatershape,
7842 fSSDCoolingTubeWater);
7843 ssdcablelay5rightwatertube->SetLineColor(7);
7844 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7845 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7846 ////////////////////////////////////
7847 // TGeoPCone Water Volumes Layer
7848 ///////////////////////////////////
7849 TGeoPcon* ssdcableslay5pconwatershape[3];
7850 TGeoVolume* ssdcableslay5pconwater[3];
7851 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7852 Double_t ssdcableslay5pconwaterzsection[6];
7853 Double_t ssdcableslay5pcwateronrmin[6];
7854 Double_t ssdcableslay5pconwaterrmax[6];
7855 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7856 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7857 + fgkSSDCablesLay5RightSideWaterHeight;
7858 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7859 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7860 + fgkSSDCablesLay5RightSideWaterHeight;
7861 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7862 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7863 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7864 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7865 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7866 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7867 ssdcableslay5pconwater[0]->SetLineColor(7);
7868 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7869 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7870////////////////////////////////////
7871 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7872 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7873 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7874 ssdcableangle,2);
7875 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7876 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7877 + fgkSSDCablesLay5RightSideWaterHeight;
7878 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7879 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7880 + fgkSSDCablesLay5RightSideWaterHeight;
7881 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7882 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7883 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7884 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7885 ssdcableslay5pconwater[1]->SetLineColor(7);
7886////////////////////////////////////
7887 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7888 ssdcableangle,2);
7889 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7890 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7891 + fgkSSDCablesLay5RightSideWaterHeight;
7892 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7893 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7894 + fgkSSDCablesLay5RightSideWaterHeight;
7895 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7896 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7897 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7898 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7899 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7900 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7901 ssdcableslay5pconwater[2]->SetLineColor(7);
7902////////////////////////////////////
7903 TGeoRotation* ssdcableslay5pconwaterot[4];
7904 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7905 for(Int_t i=0; i<4; i++){
7906 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7907 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7908 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7909 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7910 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7911 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7912 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7913 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7914 }
7915 /////////////////////////
7916 // SSD Layer 6 Cables
7917 /////////////////////////
7918 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+fgkSSDCablesLay6TubeRadiusMin;
7919 Double_t ssdcablelay6rightsidelength = 2.*ssdcablelay5rightsidelength;
7920 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+fgkSSDCablesLay6RightSideHeight;
7921 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7922 ssdcableslay6rightsideradiusmax,
7923 0.5*ssdcablelay6rightsidelength);
7924 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7925 ssdcablelay6rightubeshape,
7926 fSSDCopper);
7927 ssdcablelay6righttube->SetLineColor(9);
7928 TGeoTranslation* ssdcablelay6rightrans =
7929 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7930 + fgkEndCapSupportCenterLay6Position
7931 + 0.5*ssdcablelay6rightsidelength);
7932 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7933 - 0.5*ssdcablelay6rightsidelength
7934 - fgkEndCapSupportCenterLay6Position
7935 - fgkEndCapSupportCenterLay6ITSPosition);
7936 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7937 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7938 ////////////////////////////////////
7939 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7940 ////////////////////////////////////
7941 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7942 ssdcableangle,2);
7943 TGeoVolume* ssdcableslay6pcon;
7944 Double_t ssdcableslay6pconrmin[2];
7945 Double_t ssdcableslay6pconrmax[2];
7946 Double_t ssdcableslay6pconzsection[2];
7947 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7948 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7949 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7950 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7951 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7952 + fgkEndCapSupportCenterLay6Position
7953 + ssdcablelay6rightsidelength;
7954 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7955 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7956 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7957 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7958 ssdcableslay6pconshape,fSSDCopper);
7959 ssdcableslay6pcon->SetLineColor(9);
7960 for(Int_t i=0; i<4; i++){
7961 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7962 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7963 }
7964 ////////////////////////////////////
7965 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7966 /////////////////////////
7967 // Water Tubes Layer 6
7968 /////////////////////////
7969 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7970 ssdcableslay6rightsideradiusmax
7971 + fgkSSDCablesLay5RightSideWaterHeight,
7972 0.5*ssdcablelay6rightsidelength);
7973 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7974 ssdcablelay6righwatertubeshape,
7975 fSSDCoolingTubeWater);
7976 ssdcablelay6rightwatertube->SetLineColor(7);
7977 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7978 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7979 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7980 ssdcableangle,2);
7981 TGeoVolume* ssdcableslay6waterpcon;
7982 Double_t ssdcableslay6waterpconrmin[2];
7983 Double_t ssdcableslay6waterpconrmax[2];
7984 Double_t ssdcableslay6waterpconzsection[2];
7985 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7986 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7987 + fgkSSDCablesLay5RightSideWaterHeight;
7988 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7989 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7990 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7991 + fgkEndCapSupportCenterLay6Position
7992 + ssdcablelay6rightsidelength;
7993 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7994 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7995 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7996 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7997 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7998 ssdcableslay6waterpcon->SetLineColor(7);
7999 TGeoRotation* ssdcableslay6pconwaterot[4];
8000 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
8001 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
8002 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
8003 for(Int_t i=0; i<4; i++){
8004 ssdcableslay6pconwaterot[i] = new TGeoRotation();
8005 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
8006 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
8007 * (*ssdcableslay6pconwaterot[i]));
8008 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
8009 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
8010 }
8011 ////////////////////////////////////////
8012 // From ITS Ring to Patch Panel3-RB26
8013 ////////////////////////////////////////
8014 Double_t ssdcablepatchpanel3BB26radiusmin[2];
8015 Double_t ssdcablepatchpanel3BB26radiusmax[2];
8016 Double_t ssdcablepatchpanel3RB26zsection[2];
fcfbdd23 8017 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeigth+2.8;
47f8de53 8018 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
8019 + fgkSSDCablesLay5RightSideHeight
8020 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
8021 ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
8022 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
8023 + 0.*fgkSSDCablesLay5RightSideHeight
8024 + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
8025 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
8026 + fgkSSDCentralAL3SupportLength
8027 + fgkSSDPConeZLength[0];
8028 ssdcablepatchpanel3RB26zsection[1] = fgkSSDPatchPanel2RB26ITSDistance;
8029 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
8030 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
8031 - 0.5*ssdcableangle,ssdcableangle,2);
8032 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
8033 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
8034 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
8035 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
8036 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
8037 TGeoRotation* ssdcablepatchpanel3B26rot[3];
8038 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
67446e8a 8039 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
47f8de53 8040 ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
67446e8a 8041 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
8042 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
47f8de53 8043 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0]
67446e8a 8044 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
47f8de53 8045 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
8046 ////////////////////////////////////
8047 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
8048 ////////////////////////////////////////
8049 // ITS Ring Cables RB26 Part
8050 ////////////////////////////////////////
8051 Double_t ssdcableitsring3BB26pconzsection[2];
8052 Double_t ssdcableitsring3BB26pconrmin[2];
8053 Double_t ssdcableitsring3BB26pconrmax[2];
8054 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
8055 + fgkSSDCentralAL3SupportLength
8056 + (4.0/5.0)*fgkSSDPConeZLength[0];
8057 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
8058 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeigth;
8059 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
8060 + fgkSSDCablesLay5RightSideHeight
8061 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
8062 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
8063 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
8064 TGeoPcon* ssdcableitsring3BB26pconshape[4];
8065 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
8066 - 0.5*ssdcableangle,ssdcableangle
8067 + (fgkSSDCablesPatchPanel2RB26Angle[0]
8068 - fgkSSDCableAngle),2);
8069 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0+fgkSSDCablesPatchPanel2RB26Angle[1]
8070 - 0.5*ssdcableangle,ssdcableangle
8071 + 3.0*fgkSSDCableAngle
8072 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
8073 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-fgkSSDCablesPatchPanel2RB26Angle[0]
8074 - 0.5*ssdcableangle,ssdcableangle
8075 - fgkSSDCableAngle
8076 + fgkSSDCablesPatchPanel2RB26Angle[0],2);
8077 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+fgkSSDCablesPatchPanel2RB26Angle[1]
8078 - 0.5*ssdcableangle,ssdcableangle
8079 + 3.0*fgkSSDCableAngle
8080 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
8081 for(Int_t i=0;i<4;i++)
8082 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
8083 ssdcableitsring3BB26pconrmin[j],
8084 ssdcableitsring3BB26pconrmax[j]);
8085 TGeoVolume* ssdcableitsring3BB26pcon[4];
8086 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
8087 ssdcableitsring3BB26pconshape[0],fSSDCopper);
8088 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
8089 ssdcableitsring3BB26pconshape[1],fSSDCopper);
8090 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
8091 ssdcableitsring3BB26pconshape[2],fSSDCopper);
8092 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
8093 ssdcableitsring3BB26pconshape[3],fSSDCopper);
8094 for(Int_t i=0;i<4;i++){
8095 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
5ef8864c 8096 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
47f8de53 8097}
8098 ////////////////////////////////////
8099 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
8100 // + ssdcableitsring3BB26pconshape[1]->Capacity()
8101 // + ssdcableitsring3BB26pconshape[2]->Capacity()
8102 // + ssdcableitsring3BB26pconshape[3]->Capacity();
8103 ////////////////////////////////////////
8104 // From ITS Ring to Patch Panel2-RB24
8105 ////////////////////////////////////////
8106 Double_t ssdcablepatchpanel3BB24radiusmin[2];
8107 Double_t ssdcablepatchpanel3BB24radiusmax[2];
8108 Double_t ssdcablepatchpanel3RB24zsection[2];
8109 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
8110 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
8111 ssdcablepatchpanel3BB24radiusmin[1] = fgkSSDPatchPanel2RB24Radius;
8112 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
8113 + 0.*fgkSSDCablesLay5RightSideHeight
8114 + 0.*fgkSSDCablesLay6RightSideHeight
8115 + 0.5*fgkSSDPatchPanelHeigth;
8116 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
8117 - fgkSSDCentralAL3SupportLength
8118 - fgkSSDPConeZLength[0];
8119 ssdcablepatchpanel3RB24zsection[1] = -fgkSSDPatchPanel2RB24ITSDistance;
8120 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
8121 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
8122 - 0.5*ssdcableangle,ssdcableangle,2);
8123 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
8124 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
8125 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
8126 ssdcablepatchpanel3RB24pconshape,
8127 fSSDCopper);
8128 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
8129 TGeoRotation* ssdcablepatchpanel3B24rot[3];
8130 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
67446e8a 8131 ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
47f8de53 8132 ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0]
8133 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
67446e8a 8134 ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
47f8de53 8135 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0]
8136 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
8137 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
8138 ////////////////////////////////////
8139 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
8140 ////////////////////////////////////////
8141 // ITS Ring Cables RB24 Part
8142 ////////////////////////////////////////
8143 Double_t ssdcableitsring3BB24pconzsection[2];
8144 Double_t ssdcableitsring3BB24pconrmin[2];
8145 Double_t ssdcableitsring3BB24pconrmax[2];
8146 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
8147 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
8148 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeigth;
8149 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
8150 + fgkSSDCablesLay5RightSideHeight
8151 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
8152 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
8153 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
8154 TGeoPcon* ssdcableitsring3BB24pconshape[4];
8155 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
8156 + (90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
8157 - fgkSSDCableAngle),2);
8158 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+fgkSSDCableAngle-0.5*ssdcableangle,
8159 ssdcableangle-fgkSSDCableAngle
8160 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
8161 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
8162 - fgkSSDCableAngle
8163 + 90.0-fgkSSDCablesPatchPanel2RB24Angle[1],2);
5ef8864c 8164 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+fgkSSDCableAngle-0.5*ssdcableangle,
47f8de53 8165 ssdcableangle-fgkSSDCableAngle
8166 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
8167 for(Int_t i=0;i<4;i++)
8168 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
8169 ssdcableitsring3BB24pconrmin[j],
8170 ssdcableitsring3BB24pconrmax[j]);
8171 TGeoVolume* ssdcableitsring3BB24pcon[4];
8172 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
8173 ssdcableitsring3BB24pconshape[0],fSSDCopper);
8174 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
8175 ssdcableitsring3BB24pconshape[1],fSSDCopper);
8176 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
8177 ssdcableitsring3BB24pconshape[2],fSSDCopper);
8178 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
8179 ssdcableitsring3BB24pconshape[3],fSSDCopper);
8180 for(Int_t i=0;i<4;i++){
8181 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
5ef8864c 8182 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
47f8de53 8183}
8184 ////////////////////////////////////
8185 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
8186 // + ssdcableitsring3BB24pconshape[1]->Capacity()
8187 // + ssdcableitsring3BB24pconshape[2]->Capacity()
8188 // + ssdcableitsring3BB24pconshape[3]->Capacity();
8189 ////////////////////////////////////
8190 // Volumes for Material Budget
8191 ////////////////////////////////////
8192 TGeoTube* ssdcablelay6materialbudgetubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax
8193 + fgkSSDCablesLay5RightSideWaterHeight,
8194 ssdcableslay6rightsideradiusmax
8195 + fgkSSDCablesLay5RightSideWaterHeight
8196 + fgkSSDCableMaterialBudgetHeight,0.5*ssdcablelay6rightsidelength);
8197 TGeoVolume* ssdcablelay6materialbudgetube = new TGeoVolume("SSDCableLay6MaterialBudgetTube",
8198 ssdcablelay6materialbudgetubeshape,
8199 fSSDCopper);
8200 ssdcablelay6materialbudgetube->SetLineColor(9);
8201 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,1,ssdcablelay6rightrans);
8202 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,2,ssdcablesLay6RightTubeToLeftrans);
8203
8204 TGeoPcon* ssdcablelay6materialbudgetpconshape =
8205 new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
8206 TGeoVolume* ssdcablelay6materialbudgetpcon;
8207 Double_t ssdcablelay6materialbudgetpconrmin[2];
8208 Double_t ssdcablelay6materialbudgetpconrmax[2];
8209 Double_t ssdcablelay6materialbudgetpconzsection[2];
8210 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
8211 + fgkSSDCablesLay5RightSideWaterHeight;
8212 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
8213 + fgkSSDCableMaterialBudgetHeight;
8214 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
8215 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
8216 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
8217 + fgkEndCapSupportCenterLay6Position
8218 + ssdcablelay6rightsidelength;
8219 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
8220 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
8221 ssdcablelay6materialbudgetpconzsection[i],
8222 ssdcablelay6materialbudgetpconrmin[i],
8223 ssdcablelay6materialbudgetpconrmax[i]);
8224 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
8225 ssdcablelay6materialbudgetpconshape,fSSDCopper);
8226 ssdcablelay6materialbudgetpcon->SetLineColor(9);
8227 for(Int_t i=0; i<4; i++){
8228 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
8229 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
8230 }
8231////////////////////////////////////
8232 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
8233 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
8234 Double_t ssdcablesvolume = 0.0;
8235 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
8236 std::cout << ssdcablesvolume << std::endl;*/
8237 return ssdcablesmother;
8238 }
8239 ////////////////////////////////////////////////////////////////////////////////
d7599219 8240TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
a6e0ebfe 8241 Double_t height, const char* shapename, Int_t isign) const{
44285dfa 8242 /////////////////////////////////////////////////////////////
8243 // Method generating an Arb shape
8244 /////////////////////////////////////////////////////////////
8245 const Int_t kvertexnumber = 8;
8246 const Int_t ktransvectnumber = 2;
8247 TVector3* vertex[kvertexnumber];
8248 TVector3* transvector[2];
8249 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
8250 /////////////////////////////////////////////////////////////
d7599219 8251 //Setting the vertices for TGeoArb8
44285dfa 8252 /////////////////////////////////////////////////////////////
8253 vertex[0] = new TVector3(*vertexpos[0]);
8254 vertex[1] = new TVector3(*vertexpos[1]);
8255 vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
8256 vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
8257 vertex[4] = new TVector3(*vertexpos[2]);
8258 vertex[5] = new TVector3(*vertexpos[3]);
8259 vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
8260 vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
8261 /////////////////////////////////////////////////////////////
8262 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
8263 for(Int_t i = 0; i<kvertexnumber;i++)
8264 arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
bf210566 8265 /////////////////////////////////////////////////////////////
8266 // Deallocating memory
8267 /////////////////////////////////////////////////////////////
8268 for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
8269 for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
8270 /////////////////////////////////////////////////////////////
44285dfa 8271 return arbshape;
d7599219 8272}
bf210566 8273///////////////////////////////////////////////////////////////////////////////
8274TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8275 Double_t rmax, Int_t nedges, Double_t height){
8276 /////////////////////////////////////////////////////////////
8277 // Method generating Arc shape
8278 /////////////////////////////////////////////////////////////
8279 const Int_t kvertexnumber = 2*nedges+2;
8280 TGeoXtru* arcshape = new TGeoXtru(2);
8281 TVector3** vertexposition[2];
8282 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8283 Double_t angle = 0.;
8284 for(Int_t i=0; i<nedges+1; i++){
8285 angle = 90.+0.5*phi-i*(phi/nedges);
8286 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
8287 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
8288 }
8289 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8290 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8291 for(Int_t i=0; i<kvertexnumber; i++){
8292 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8293 yvertexpoints[i] = vertexposition[0][i]->Y();
8294 }
8295 else if(i>=1&&i<nedges+2)
8296 {
8297 xvertexpoints[i] = vertexposition[1][i-1]->X();
8298 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8299 }
8300 else
8301 {
8302 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8303 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8304 }
8305 }
8306 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8307 arcshape->DefineSection(0,-0.5*height);
8308 arcshape->DefineSection(1,0.5*height);
44285dfa 8309 /////////////////////////////////////////////////////////////
bf210566 8310 // Deallocating memory
44285dfa 8311 /////////////////////////////////////////////////////////////
bf210566 8312 for(Int_t i=0; i<2; i++){
8313 for(Int_t j=0; j<nedges+1; j++)
8314 delete vertexposition[i][j];
8315 delete [] vertexposition[i];
8316 }
8317 delete [] xvertexpoints;
8318 delete [] yvertexpoints;
8319 /////////////////////////////////////////////////////////////
8320 return arcshape;
d7599219 8321}
8322////////////////////////////////////////////////////////////////////////////////
851c0ce3 8323TGeoShape* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
9b0c60ab 8324 ///////////////////////////////////////////////////////////////////////
8325 // Method Generating the Screw Shape
8326 // radius[0]: outer radius
8327 // radius[1]: inner radius
8328 // edgesnumber[0]: outer number of edges
8329 // edgesnumber[1]: inner number of edges
8330 // section[0]: lower section position
8331 // section[1]: higher section position
8332 ///////////////////////////////////////////////////////////////////////
8333 Double_t outradius = radius[0];
8334 Double_t inradius = radius[1];
8335 Int_t outvertexnumber = edgesnumber[0];
8336 Int_t invertexnumber = edgesnumber[1];
851c0ce3 8337 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8338 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8339 for(Int_t i=0; i<outvertexnumber; i++){
9b0c60ab 8340 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8341 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8342 }
851c0ce3 8343 for(Int_t i=0; i<invertexnumber; i++){
8344 xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8345 yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
9b0c60ab 8346 }
851c0ce3 8347 TGeoXtru* screwshapeout = new TGeoXtru(2);
8348 screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8349 screwshapeout->DefineSection(0,section[0]);
8350 screwshapeout->DefineSection(1,section[1]);
8351 TGeoXtru* screwshapein = new TGeoXtru(2);
8352 screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8353 screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8354 screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8355 TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8356 TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8357
9b0c60ab 8358 delete [] xscrewvertex;
8359 delete [] yscrewvertex;
8360 return screwshape;
8361}
8362////////////////////////////////////////////////////////////////////////////////
851c0ce3 8363TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
9b0c60ab 8364 ///////////////////////////////////////////////////////////////////////
8365 // Method Generating the Hole Shape
8366 // radius of the Hole
8367 // nedges: number of edges to approximate the circle
8368 ///////////////////////////////////////////////////////////////////////
851c0ce3 8369 Double_t* xholevertex = new Double_t[nedges];
8370 Double_t* yholevertex = new Double_t[nedges];
8371 Double_t z = 0.5*(section[0]+section[1]);
8372 Double_t dz = 0.5*(section[1]-section[0]);
8373 TGeoTranslation *tr = 0;
8374 if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8375 tr = new TGeoTranslation(0.,0.,z);
8376 tr->RegisterYourself();
8377 }
8378 TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8379 for(Int_t i=0; i<nedges; i++){
8380 xholevertex[i] = radius*CosD(i*360./nedges);
8381 yholevertex[i] = radius*SinD(i*360./nedges);
9b0c60ab 8382 }
851c0ce3 8383 TGeoXtru* holeshapeout = new TGeoXtru(2);
8384 holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8385 holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8386 holeshapeout->DefineSection(1,section[1]+0.01);
8387 TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8388 TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8389
9b0c60ab 8390 delete [] xholevertex;
8391 delete [] yholevertex;
8392 return holeshape;
8393}
8394////////////////////////////////////////////////////////////////////////////////
44285dfa 8395TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
8396 /////////////////////////////////////////////////////////////
8397 // Given an axis specified by param, it gives the reflection of the point
8398 // respect to the axis
8399 /////////////////////////////////////////////////////////////
8400 TVector3* n = new TVector3(param[0],param[1],param[2]);
8401 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8402 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 8403 /////////////////////////////////////////////////////////////
8404 // Deallocating memory
8405 /////////////////////////////////////////////////////////////
8406 delete n;
8407 /////////////////////////////////////////////////////////////
44285dfa 8408 return reflectedvector;
d7599219 8409}
8410////////////////////////////////////////////////////////////////////////////////
bf210566 8411TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
d7599219 8412 Double_t dx,
8413 Double_t dy,
8414 Double_t dz) const{
44285dfa 8415 /////////////////////////////////////////////////////////////
d7599219 8416 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 8417 /////////////////////////////////////////////////////////////
bf210566 8418 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8419 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 8420 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 8421 hmatrix->SetTranslation(newvect);
8422 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8423 delete hmatrix;
8424 return matrix;
d7599219 8425}
8426////////////////////////////////////////////////////////////////////////////////
d7599219 8427TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 8428 /////////////////////////////////////////////////////////////
8429 // Method returning the Medium type
8430 /////////////////////////////////////////////////////////////
a3f8715e 8431 char ch[100];
d7599219 8432 sprintf(ch, "ITS_%s",mediumName);
8433 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8434 if (! medium)
8435 printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
8436 return medium;
8437}
8438////////////////////////////////////////////////////////////////////////////////
d7599219 8439void AliITSv11GeometrySSD::CreateMaterials(){
8440///////////////////////////////////
8441// This part has to be modified
8442///////////////////////////////////
8443 ///////////////////////////////////
8444 // Silicon for Sensor
8445 ///////////////////////////////////
bf210566 8446 fSSDSensorMedium = GetMedium("SI$");
d7599219 8447 ///////////////////////////////////
8448 // Silicon Mixture for Sensor
8449 ///////////////////////////////////
44285dfa 8450 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8451 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 8452 ///////////////////////////////////
8453 // Stiffener Components Materials
8454 ///////////////////////////////////
bf210566 8455 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 8456 ///////////////////////////
8457 // Stiffener Connectors
8458 ///////////////////////////
bf210566 8459 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 8460 ////////////////////////////////
8461 // Stiffener 0603-1812 Capacitor
8462 ////////////////////////////////
bf210566 8463 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8464 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
d7599219 8465 ///////////////////////////
8466 // Stiffener Hybrid Wire
8467 ///////////////////////////
bf210566 8468 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 8469 ///////////////////////////
8470 // Al for Cooling Block
8471 ///////////////////////////
bf210566 8472 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 8473 //////////////////////////////////////////////////////
8474 // Kapton and Al for Chip Cable Flex and Ladder Cables
8475 //////////////////////////////////////////////////////
bf210566 8476 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8477 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8478 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8479 fSSDAlTraceFlexMedium = GetMedium("AL$");
8480 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8481 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 8482 /////////////////////////////////////////////////////////////////
8483 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8484 //////////////////////////////////////////////////////////////////
44285dfa 8485 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 8486 /////////////////////////////////////////////////////////////////
8487 // G10 for Detector Leg, TubeHolder
8488 //////////////////////////////////////////////////////////////////
44285dfa 8489 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8490 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8491 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8492 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 8493 /////////////////////////////////////////////////////////////////
8494 // Water and Phynox for Cooling Tube
8495 //////////////////////////////////////////////////////////////////
bf210566 8496 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 8497 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 8498 /////////////////////////////////////////////////////////////////////
9b0c60ab 8499 // Material for Support Rings
8500 /////////////////////////////////////////////////////////////////////
8501 fSSDSupportRingAl = GetMedium("AL$");
47f8de53 8502 fSSDRohaCellCone = GetMedium("ROHACELL$");
9b0c60ab 8503 /////////////////////////////////////////////////////////////////////
bf210566 8504 fSSDAir = GetMedium("SDD AIR$");
47f8de53 8505 fSSDCopper = GetMedium("COPPER$");
bf210566 8506 fCreateMaterials = kTRUE;
d7599219 8507}
8508/////////////////////////////////////////////////////////////////////