]> 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
Commenting out debug printouts
[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"
160835d5 41#include "Riostream.h"
d7599219 42/////////////////////////////////////////////////////////////////////////////////
bf210566 43// Names of the Sensitive Volumes of Layer 5 and Layer 6
44/////////////////////////////////////////////////////////////////////////////////
02d4acf9 45const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5";
46const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6";
bf210566 47/////////////////////////////////////////////////////////////////////////////////
d7599219 48//Parameters for SSD Geometry
49/////////////////////////////////////////////////////////////////////////////////
e21cdd03 50// Variable for Vertical Disalignement of Modules
51/////////////////////////////////////////////////////////////////////////////////
ca86fdb4 52const Double_t AliITSv11GeometrySSD::fgkSSDTolerance = 0.0001*fgkmm;
0fb26117 53const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
54const Double_t AliITSv11GeometrySSD::fgkSSDModuleSideDisalignment = 0.2*fgkmm;
160835d5 55// For ladders:
cd2243fb 56const Double_t AliITSv11GeometrySSD::fgkSSDLadderVerticalDisalignment = 0.520*fgkmm;
e21cdd03 57/////////////////////////////////////////////////////////////////////////////////
d7599219 58// Layer5 (lengths are in mm and angles in degrees)
59/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 60const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
d7599219 61const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
62const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
9acf2ecc 63const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
64const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
65const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
d7599219 66/////////////////////////////////////////////////////////////////////////////////
67// Layer6 (lengths are in mm and angles in degrees)
68/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 69const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
d7599219 70const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
71const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
9acf2ecc 72const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
73const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
74const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
d7599219 75/////////////////////////////////////////////////////////////////////////////////
76// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
77/////////////////////////////////////////////////////////////////////////////////
78const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
9acf2ecc 79const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
80const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
81const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
82const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
bf210566 83const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
84const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
9acf2ecc 85const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
d7599219 86/////////////////////////////////////////////////////////////////////////////////
87// Stiffener (lengths are in mm and angles in degrees)
88/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 89const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
90const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
bf210566 91//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 3.315;
9acf2ecc 92const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm;
93const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
bf210566 94const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
9acf2ecc 95const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
96const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
97const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
98const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
bf210566 99const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 0.700*fgkmm; // multiplied by 0.5
9acf2ecc 100const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
101const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
bf210566 102const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] =
103 {44.32*fgkmm, 0.33*fgkmm};
104const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
105const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
106const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
d7599219 107const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight =
bf210566 108 0.25*fgkSSDStiffenerHeight;
109const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
110const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
d7599219 111/////////////////////////////////////////////////////////////////////////////////
112// Cooling Block (lengths are in mm and angles in degrees)
113/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 114const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
115const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
bf210566 116const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
117 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
d7599219 118const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
bf210566 119 {1.000*fgkmm, 0.120*fgkmm};
d7599219 120const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
bf210566 121 {1.900*fgkmm, 0.400*fgkmm};
d7599219 122const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
9acf2ecc 123 1.500*fgkmm;
d7599219 124const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
9acf2ecc 125 0.300*fgkmm;
d7599219 126/////////////////////////////////////////////////////////////////////////////////
127// SSD Sensor (lengths are in mm and angles in degrees)
128/////////////////////////////////////////////////////////////////////////////////
129const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
bf210566 130 "SSDSensorSensitiveVol";
9acf2ecc 131const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
132const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
133const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
d7599219 134const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
9acf2ecc 135 fgkSSDSensorLength-39.1*fgkmm;
bf210566 136const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
137const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
d7599219 138/////////////////////////////////////////////////////////////////////////////////
139// Flex (lengths are in mm and angles in degrees)
140/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 141const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
d7599219 142const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
bf210566 143 {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
144 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
145 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
146 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
147 - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
d7599219 148const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
bf210566 149 { 9.340*fgkmm, 5.380*fgkmm};
d7599219 150const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
bf210566 151 { 0.030*fgkmm, 0.020*fgkmm};
d7599219 152const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
9acf2ecc 153const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
154const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
d7599219 155const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
bf210566 156 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
d7599219 157const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
bf210566 158 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
d7599219 159/////////////////////////////////////////////////////////////////////////////////
160// SSD Ladder Cable (lengths are in mm and angles in degrees)
161/////////////////////////////////////////////////////////////////////////////////
bf210566 162const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
d7599219 163/////////////////////////////////////////////////////////////////////////////////
164// SSD Module (lengths are in mm and angles in degrees)
165/////////////////////////////////////////////////////////////////////////////////
166const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
bf210566 167 { 1.000*fgkmm, 3.900*fgkmm};
d7599219 168const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
9acf2ecc 169 45.600*fgkmm;
d7599219 170const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
9acf2ecc 171 5.075*fgkmm;
d7599219 172/////////////////////////////////////////////////////////////////////////////////
173// Sensor Support (lengths are in mm and angles in degrees)
174/////////////////////////////////////////////////////////////////////////////////
bf210566 175const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
176 5.800*fgkmm;
d7599219 177const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
bf210566 178 2.000*fgkmm;
d7599219 179const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
0fb26117 180 { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment,
181 5.220*fgkmm-fgkSSDModuleVerticalDisalignment};
ca86fdb4 182//const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
183// { 4.520*fgkmm, 5.130*fgkmm};
bf210566 184const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
185 { 0.450*fgkmm, 0.450*fgkmm};
186const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
187 = 0.5 * (fgkSSDModuleSensorSupportDistance
188 + fgkSSDSensorSideSupportThickness[0])
189 - fgkSSDSensorSideSupportLength;
d7599219 190const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
bf210566 191 5.250*fgkmm;
d7599219 192const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
bf210566 193 1.680*fgkmm;
194const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
195 = {fgkSSDSensorSideSupportHeight[0]
196 + fgkSSDSensorSideSupportThickness[0],
197 fgkSSDSensorSideSupportHeight[1]
198 + fgkSSDSensorSideSupportThickness[1]};
199const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
200 = {fgkSSDSensorSideSupportThickness[0],
201 fgkSSDSensorSideSupportThickness[1]};
d7599219 202const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
bf210566 203 19.000*fgkmm;
d7599219 204/////////////////////////////////////////////////////////////////////////////////
205// Chip Cables (lengths are in mm and angles in degrees)
206/////////////////////////////////////////////////////////////////////////////////
207const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
bf210566 208 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
d7599219 209const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
bf210566 210 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
211 - (fgkSSDSensorSideSupportHeight[1]
212 - fgkSSDSensorSideSupportHeight[0])
0fb26117 213 - fgkSSDModuleVerticalDisalignment
bf210566 214 - fgkSSDCoolingBlockHoleCenter
215 - fgkSSDStiffenerHeight
216 - fgkSSDChipHeight-fgkSSDSensorHeight,
217 fgkSSDModuleCoolingBlockToSensor
0fb26117 218 - fgkSSDModuleVerticalDisalignment
bf210566 219 - fgkSSDCoolingBlockHoleCenter
220 - fgkSSDStiffenerHeight
221 - fgkSSDChipHeight-fgkSSDSensorHeight};
d7599219 222const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
bf210566 223 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
d7599219 224/////////////////////////////////////////////////////////////////////////////////
225// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
226/////////////////////////////////////////////////////////////////////////////////
227const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
bf210566 228 3.820*fgkmm;
229//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
230// 3.780;
d7599219 231const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
bf210566 232 fgkSSDSensorLength-fgkSSDSensorOverlap;
d7599219 233const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
bf210566 234 { 0.86*fgkmm, 0.30*fgkmm};
d7599219 235const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
bf210566 236 { 30.00, 90.00};
d7599219 237const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
bf210566 238 1.78*fgkmm;
d7599219 239/////////////////////////////////////////////////////////////////////////////////
240//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
241/////////////////////////////////////////////////////////////////////////////////
bf210566 242const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
243 = fgkSSDModuleSensorSupportDistance
244 - 2. * fgkCarbonFiberJunctionToSensorSupport;
245const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
d7599219 246const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
bf210566 247 { 0.751*fgkmm, 0.482*fgkmm};
248const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
249 1.630*fgkmm;
250const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
251const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
252 = fgkCarbonFiberTriangleLength
253 - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
254 / TMath::Cos(fgkCarbonFiberTriangleAngle
255 * TMath::DegToRad());
256const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
257 = 0.5*(fgkCarbonFiberJunctionWidth
258 - fgkCarbonFiberSupportWidth)
259 - fgkCarbonFiberSupportTopEdgeDist[0]
260 - fgkCarbonFiberSupportWidth;
d7599219 261/////////////////////////////////////////////////////////////////////////////////
262// Carbon Fiber Lower Support Parameters (lengths are in mm)
263/////////////////////////////////////////////////////////////////////////////////
c40ebacc 264const Double_t AliITSv11GeometrySSD::fgkLowerSupportToSensorZ = 11.575*fgkmm;
d7599219 265const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
9acf2ecc 266 = 0.950*fgkmm;
d7599219 267const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
9acf2ecc 268 = 1.600*fgkmm;
d7599219 269const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
9acf2ecc 270 = 0.830*fgkmm;
d7599219 271const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
272 = 0.5*fgkCarbonFiberSupportWidth;
273const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
bf210566 274 = fgkCarbonFiberJunctionWidth
275 - 2. * (fgkCarbonFiberLowerSupportWidth
276 + fgkCarbonFiberLowerSupportVolumeSeparation);
d7599219 277const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
bf210566 278 = {fgkCarbonFiberLowerSupportWidth
279 + fgkCarbonFiberLowerSupportVolumeSeparation,
280 fgkCarbonFiberLowerSupportWidth
281 + fgkCarbonFiberLowerSupportVolumeSeparation
282 + fgkCarbonFiberLowerSupportTransverseWidth};
d7599219 283/////////////////////////////////////////////////////////////////////////////////
284// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
285/////////////////////////////////////////////////////////////////////////////////
286const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
bf210566 287 {0.5 * (fgkSSDLay5LadderLength
288 - fgkSSDLay5SensorsNumber
289 * fgkCarbonFiberJunctionWidth
290 - fgkCarbonFiberLowerSupportWidth),
291 0.5 * (fgkSSDLay5LadderLength
292 - fgkSSDLay5SensorsNumber
293 * fgkCarbonFiberJunctionWidth
294 + fgkCarbonFiberLowerSupportWidth)};
d7599219 295const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
bf210566 296 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
297 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
d7599219 298const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
bf210566 299 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
300 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
9b0c60ab 301const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
302 {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
d7599219 303/////////////////////////////////////////////////////////////////////////////////
304// Cooling Tube Support (lengths are in mm and angles in degrees)
305/////////////////////////////////////////////////////////////////////////////////
bf210566 306const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
d7599219 307const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
308 = fgkSSDCoolingBlockHoleRadius[0];
bf210566 309const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
310const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
311const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
d7599219 312const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
bf210566 313 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
314const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
315 11.70*fgkmm;
d7599219 316/////////////////////////////////////////////////////////////////////////////////
317// Cooling Tube (lengths are in mm and angles in degrees)
318/////////////////////////////////////////////////////////////////////////////////
bf210566 319const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
320const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm;
321const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
d7599219 322 fgkCarbonFiberJunctionWidth;
323const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
bf210566 324 fgkSSDModuleSensorSupportDistance
325 + fgkSSDCoolingBlockLength;
9b0c60ab 326const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
d7599219 327/////////////////////////////////////////////////////////////////////////////////
328// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
329/////////////////////////////////////////////////////////////////////////////////
330const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
bf210566 331 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
d7599219 332const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
bf210566 333 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
d7599219 334const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
bf210566 335 20.0*fgkmm;
d7599219 336const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
bf210566 337 40.0;
d7599219 338const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
339 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
340const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
bf210566 341 2.5*fgkmm;
d7599219 342const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
bf210566 343 { 56.0*fgkmm, 12.0*fgkmm};
d7599219 344const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
bf210566 345 { 5.0*fgkmm, 2.9*fgkmm};
d7599219 346const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
bf210566 347 1.0*fgkmm;
d7599219 348const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
bf210566 349 6.0*fgkmm;
cd2243fb 350const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeight =
bf210566 351 4.0*fgkmm;
d7599219 352const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
bf210566 353 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
d7599219 354/////////////////////////////////////////////////////////////////////////////////
9b0c60ab 355// SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
356/////////////////////////////////////////////////////////////////////////////////
357const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
358const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
359const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
360const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
361const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
362/////////////////////////////////////////////////////////////////////////////////
363// SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
364/////////////////////////////////////////////////////////////////////////////////
365const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
366const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
367const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
368 - fgkSSDMountingBlockHeight[1]
369 + 0.5*fgkCoolingTubeSupportHeight
370 + fgkSSDModuleCoolingBlockToSensor
371 - fgkMountingBlockSupportDownHeight,
372 fgkSSDLay6RadiusMin
373 - fgkSSDMountingBlockHeight[1]
374 + 0.5*fgkCoolingTubeSupportHeight
375 + fgkSSDModuleCoolingBlockToSensor
376 - fgkMountingBlockSupportDownHeight};
377const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
378 - fgkSSDMountingBlockHeight[1]
379 + 0.5*fgkCoolingTubeSupportHeight
380 + fgkSSDModuleCoolingBlockToSensor
381 - fgkMountingBlockSupportRadius[0],
382 fgkSSDLay6RadiusMax
383 - fgkSSDMountingBlockHeight[1]
384 + 0.5*fgkCoolingTubeSupportHeight
385 + fgkSSDModuleCoolingBlockToSensor
386 - fgkMountingBlockSupportRadius[1]};
cd2243fb 387const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeight = 10.0*fgkmm; // To be verified
9b0c60ab 388const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
389const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
390/////////////////////////////////////////////////////////////////////////////////
391// SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
392/////////////////////////////////////////////////////////////////////////////////
393const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
394const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
395const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
396const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
397 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
398const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
399 {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
400const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
401 {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
402const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
403const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
404const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
405const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
406const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
407const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
408/////////////////////////////////////////////////////////////////////////////////
409// SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
410/////////////////////////////////////////////////////////////////////////////////
411const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
412const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
413const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
414/////////////////////////////////////////////////////////////////////////////////
415// SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
416/////////////////////////////////////////////////////////////////////////////////
417const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
418 {10.5*fgkmm,9.25*fgkmm};
419const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
420const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
421const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
422 {182.3,177.9,84.4,70.0,35.0};
423const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
424 {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
425const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
426/////////////////////////////////////////////////////////////////////////////////
427// SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
428/////////////////////////////////////////////////////////////////////////////////
429const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
430 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
431const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
432 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
433 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
434const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
435/////////////////////////////////////////////////////////////////////////////////
436// SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
437/////////////////////////////////////////////////////////////////////////////////
438const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
439 {62.0*fgkmm,21.87*fgkmm};
440const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
7708d5f3 441 {47.0*fgkmm,0.35*fgkmm};
9b0c60ab 442const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
443 1.0*fgkmm;
444const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
445const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
446 {43.5*fgkmm, 0.70*fgkmm};
447const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
448 0.15*fgkmm;
449const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
450 19.0*fgkmm;
451const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
452 {4.80*fgkmm,1.1*fgkmm};
453const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
454 {3.3*fgkmm,1.10*fgkmm};
455const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
456 2.1*fgkmm;
457const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
458 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
459const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
460 {1.9*fgkmm,0.15*fgkmm};
461const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
462 19*fgkmm;
463const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
464 1.0*fgkmm;
465const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
466 3.6*fgkmm;
467const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
468 61.0*fgkmm;
469const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
470 5.97*fgkmm;
471const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
472const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
473 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
474 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
475const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
476 {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
477const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
478 1.0*fgkmm;
479const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
480 = 0.15*fgkmm;
481const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
482 20.0*fgkmm;
483const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
484const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
485const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
486const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
487const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
488/////////////////////////////////////////////////////////////////////////////////
489// SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
490/////////////////////////////////////////////////////////////////////////////////
491const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
492const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
47f8de53 493const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {375.0*fgkmm,435.0*fgkmm};
9b0c60ab 494const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
495const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
496const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
497const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
498const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
499const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
500/////////////////////////////////////////////////////////////////////////////////
47f8de53 501// SSD Cone Parameters (lengths are in mm and angles in degrees)
502/////////////////////////////////////////////////////////////////////////////////
503const Double_t AliITSv11GeometrySSD::fgkSSDLowerPConeRadius = 296.5*fgkmm;
504const Double_t AliITSv11GeometrySSD::fgkSSDPConeAngle = 39.0;
fcfbdd23 505const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {168.0*fgkmm,153.0*fgkmm};
47f8de53 506const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleRadius = 317.5*fgkmm;
507const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleLength = 20.*fgkmm;
508const Double_t AliITSv11GeometrySSD::fgkSSDConeMiddleRadius = 350.*fgkmm;
509const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleLength = 30.*fgkmm;
510const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleWidth = 40.*fgkmm;
511const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpRadius = 400.*fgkmm;
fcfbdd23 512const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 459.*fgkmm;
47f8de53 513const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMiddleRadius = 472.5*fgkmm;
514const Double_t AliITSv11GeometrySSD::fgkSSDPConeDownRadius = 282.0*fgkmm;
515const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidAngle = 42.0;
516const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidBasis = 200.0*fgkmm;
517const Double_t AliITSv11GeometrySSD::fgkSSDPConeExternalRadius = 492.5*fgkmm;
518const Double_t AliITSv11GeometrySSD::fgkSSDPConeRadiusWidth = 16.75*fgkmm;
fcfbdd23 519const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 168.0*fgkmm;
47f8de53 520const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportLength = 1020.*fgkmm;
521const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm;
522const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm;
523const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportLength = 60.0*fgkmm;
524const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportWidth = 2.5*fgkSSDCentralSupportWidth;
525/////////////////////////////////////////////////////////////////////////////////
526// SSD Cables Parameters (lengths are in mm and angles in degrees)
527/////////////////////////////////////////////////////////////////////////////////
528const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
529const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
530const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
531const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
532const Double_t AliITSv11GeometrySSD::fgkSSDCableAngle = 22.5;
533const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm; // to be fixed in order to reproduce material budget
534const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
535const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
536const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
537const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
538const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = 451.3*fgkmm;
539const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = 451.3*fgkmm;
cd2243fb 540const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeight = 87.5*fgkmm;
47f8de53 541const Double_t AliITSv11GeometrySSD::fgkSSDCableMaterialBudgetHeight = 20.0*fgkmm;
542//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = fgkSSDPConeExternalRadius;
543//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = fgkSSDPConeExternalRadius;
544/////////////////////////////////////////////////////////////////////////////////
44285dfa 545ClassImp(AliITSv11GeometrySSD)
546/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 547AliITSv11GeometrySSD::AliITSv11GeometrySSD():
548 AliITSv11Geometry(),
44285dfa 549 fSSDChipMedium(),
550 fSSDChipGlueMedium(),
551 fSSDStiffenerMedium(),
552 fSSDStiffenerConnectorMedium(),
553 fSSDStiffener0603CapacitorMedium(),
554 fSSDStiffener1812CapacitorMedium(),
555 fSSDStiffenerHybridWireMedium(),
556 fSSDKaptonFlexMedium(),
557 fSSDAlTraceFlexMedium(),
558 fSSDAlTraceLadderCableMedium(),
559 fSSDKaptonLadderCableMedium(),
560 fSSDKaptonChipCableMedium(),
561 fSSDAlTraceChipCableMedium(),
562 fSSDAlCoolBlockMedium(),
563 fSSDSensorMedium(),
564 fSSDSensorSupportMedium(),
565 fSSDCarbonFiberMedium(),
566 fSSDTubeHolderMedium(),
567 fSSDCoolingTubeWater(),
568 fSSDCoolingTubePhynox(),
9b0c60ab 569 fSSDSupportRingAl(),
44285dfa 570 fSSDMountingBlockMedium(),
47f8de53 571 fSSDRohaCellCone(),
bf210566 572 fSSDAir(),
47f8de53 573 fSSDCopper(),
bf210566 574 fCreateMaterials(kFALSE),
575 fTransformationMatrices(kFALSE),
576 fBasicObjects(kFALSE),
577 fcarbonfiberjunction(),
578 fcoolingtubesupport(),
579 fhybridmatrix(),
580 fssdcoolingblocksystem(),
581 fcoolingblocksystematrix(),
582 fssdstiffenerflex(),
583 fssdendflex(),
cd2243fb 584 fcoolingtube(0),
9b0c60ab 585 fendladdercoolingtubesupportmatrix(),
bf210566 586 fendladdermountingblock(),
9b0c60ab 587 fendladdermountingblockclip(),
bf210566 588 fSSDSensor5(),
589 fSSDSensor6(),
590 fSSDLayer5(),
591 fSSDLayer6(),
592 fMotherVol(),
9b0c60ab 593 fLay5LadderSupportRing(),
594 fLay6LadderSupportRing(),
e5bf64ae 595 fgkEndCapSupportSystem(),
47f8de53 596 fSSDCone(),
44285dfa 597 fColorCarbonFiber(4),
598 fColorRyton(5),
bf210566 599 fColorPhynox(14),
44285dfa 600 fColorSilicon(3),
bf210566 601 fColorAl(38),
44285dfa 602 fColorKapton(6),
603 fColorPolyhamide(5),
604 fColorStiffener(9),
bf210566 605 fColorEpoxy(30),
606 fColorWater(7),
607 fColorG10(41)
44285dfa 608{
609 ////////////////////////
610 // Standard constructor
611 ////////////////////////
44285dfa 612}
613/////////////////////////////////////////////////////////////////////////////////
614AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
9acf2ecc 615 AliITSv11Geometry(s.GetDebug()),
44285dfa 616 fSSDChipMedium(s.fSSDChipMedium),
617 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
618 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
619 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
620 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
621 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
622 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
623 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
624 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
625 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
626 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
627 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
628 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
629 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
630 fSSDSensorMedium(s.fSSDSensorMedium),
631 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
632 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
633 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
634 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
635 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
9b0c60ab 636 fSSDSupportRingAl(s.fSSDSupportRingAl),
44285dfa 637 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
47f8de53 638 fSSDRohaCellCone(s.fSSDRohaCellCone),
bf210566 639 fSSDAir(s.fSSDAir),
47f8de53 640 fSSDCopper(s.fSSDCopper),
bf210566 641 fCreateMaterials(s.fCreateMaterials),
642 fTransformationMatrices(s.fTransformationMatrices),
643 fBasicObjects(s.fBasicObjects),
644 fcarbonfiberjunction(s.fcarbonfiberjunction),
645 fcoolingtubesupport(s.fcoolingtubesupport),
646 fhybridmatrix(s.fhybridmatrix),
647 fssdcoolingblocksystem(s.fssdcoolingblocksystem),
648 fcoolingblocksystematrix(s.fcoolingblocksystematrix),
649 fssdstiffenerflex(s.fssdstiffenerflex),
650 fssdendflex(s.fssdendflex),
cd2243fb 651 fcoolingtube(s.fcoolingtube),
9b0c60ab 652 fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
bf210566 653 fendladdermountingblock(s.fendladdermountingblock),
9b0c60ab 654 fendladdermountingblockclip(s.fendladdermountingblockclip),
bf210566 655 fSSDSensor5(s.fSSDSensor5),
656 fSSDSensor6(s.fSSDSensor6),
657 fSSDLayer5(s.fSSDLayer5),
658 fSSDLayer6(s.fSSDLayer6),
44285dfa 659 fMotherVol(s.fMotherVol),
9b0c60ab 660 fLay5LadderSupportRing(s.fLay5LadderSupportRing),
661 fLay6LadderSupportRing(s.fLay6LadderSupportRing),
e5bf64ae 662 fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
47f8de53 663 fSSDCone(s.fSSDCone),
44285dfa 664 fColorCarbonFiber(s.fColorCarbonFiber),
665 fColorRyton(s.fColorRyton),
666 fColorPhynox(s.fColorPhynox),
667 fColorSilicon(s.fColorSilicon),
668 fColorAl(s.fColorAl),
669 fColorKapton(s.fColorKapton),
670 fColorPolyhamide(s.fColorPolyhamide),
671 fColorStiffener(s.fColorStiffener),
bf210566 672 fColorEpoxy(s.fColorEpoxy),
673 fColorWater(s.fColorWater),
674 fColorG10(s.fColorG10)
44285dfa 675{
676 ////////////////////////
677 // Copy Constructor
678 ////////////////////////
d7599219 679}
680/////////////////////////////////////////////////////////////////////////////////
44285dfa 681AliITSv11GeometrySSD& AliITSv11GeometrySSD::
682operator=(const AliITSv11GeometrySSD &s){
683 ////////////////////////
684 // Assignment operator
685 ////////////////////////
686 this->~AliITSv11GeometrySSD();
687 new(this) AliITSv11GeometrySSD(s);
688 return *this;
689/*
690 if(&s == this) return *this;
691 fMotherVol = s.fMotherVol;
692 return *this;
693 */
694}
bf210566 695///////////////////////////////////////////////////////////////////////////////
696void AliITSv11GeometrySSD::CreateTransformationMatrices(){
697 ///////////////////////////////////////////////////////////////////////
698 // Method generating the trasformation matrix for the whole SSD Geometry
699 ///////////////////////////////////////////////////////////////////////
700 // Setting some variables for Carbon Fiber Supportmatrix creation
701 //////////////////////////////////////////////////////////////////////
702 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
703 * CosD(fgkCarbonFiberJunctionAngle[0]);
704 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
705 + fgkCarbonFiberSupportTopEdgeDist[0]
706 + fgkCarbonFiberSupportWidth);
707 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
708 * TanD(fgkCarbonFiberJunctionAngle[0]);
709 TGeoRotation* carbonfiberot[3];
710 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
711 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
712 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
713 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
714 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
715 * CosD(fgkCarbonFiberTriangleAngle),0.,
716 - fgkCarbonFiberTriangleLength
717 * SinD(fgkCarbonFiberTriangleAngle)};
718 ///////////////////////////////////////////
719 //Setting Local Translations and Rotations:
720 ///////////////////////////////////////////
721 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
722 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
723 0.5*carbonfibersupportheight,NULL);
724 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
725 2.*symmetryplaneposition+transvector[1],
726 transvector[2], carbonfiberot[2]);
727 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
728 /////////////////////////////////////////////////////////////
729 // Carbon Fiber Support Transformations
730 /////////////////////////////////////////////////////////////
731 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
732 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
733 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
734 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
735 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
736 }
737 /////////////////////////////////////////////////////////////
738 // Carbon Fiber Junction Transformation
739 /////////////////////////////////////////////////////////////
740 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
741 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
742 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
743 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
744 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
745 localcarbonfiberjunctionmatrix[i] =
746 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
747 localcarbonfiberjunctionrot[i] =
748 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
749 localcarbonfiberjunctiontrans[i] =
750 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 751 }
bf210566 752 ///////////////////////
753 // Setting Translations
754 ///////////////////////
755 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
756 localcarbonfiberjunctiontrans[1][0] =
757 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
758 localcarbonfiberjunctiontrans[2][0] =
759 new TGeoTranslation(fgkCarbonFiberTriangleLength
760 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
761 fgkCarbonFiberTriangleLength
762 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
763 localcarbonfiberjunctiontrans[0][1] =
764 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
765 localcarbonfiberjunctiontrans[1][1] =
766 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
767 localcarbonfiberjunctiontrans[2][1] =
768 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
769 ////////////////////
770 // Setting Rotations
771 ////////////////////
772 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
773 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
774 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
775 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
776 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
777 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
778 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
779 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
780 ////////////////////////////////////////
781 // Setting Carbon Fiber Junction matrix
782 ////////////////////////////////////////
783 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
784 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
785 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
786 localcarbonfiberjunctionmatrix[i][j] =
787 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
788 *localcarbonfiberjunctionrot[i][j]);
789 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
790 }
d7599219 791 }
bf210566 792 /////////////////////////////////////////////////////////////
793 // Carbon Fiber Lower Support Transformations
794 /////////////////////////////////////////////////////////////
795 TGeoTranslation* localcarbonfiberlowersupportrans[2];
796 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
797 fgkCarbonFiberLowerSupportVolumePosition[1]
798 + fgkCarbonFiberLowerSupportVolumePosition[0],
799 0.0);
800 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
801 fgkCarbonFiberJunctionWidth
802 - fgkCarbonFiberLowerSupportWidth
803 - fgkCarbonFiberLowerSupportVolumePosition[0]
804 - fgkCarbonFiberLowerSupportVolumePosition[1],
805 - 0.5*fgkCarbonFiberLowerSupportHeight);
806 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
807 fcarbonfiberlowersupportrans[0] =
808 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
809 fcarbonfiberlowersupportrans[1] =
810 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
811 /////////////////////////////////////////////////////////////
812 // SSD Sensor Support Transformations
813 /////////////////////////////////////////////////////////////
814 const Int_t kssdsensorsupportmatrixnumber = 3;
815 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
816 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
817 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
818 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
819 localssdsensorsupportmatrix[i] =
820 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
821 localssdsensorsupportrot[i] =
822 new TGeoRotation*[kssdsensorsupportmatrixnumber];
823 localssdsensorsupportrans[i] =
824 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 825 }
bf210566 826 ///////////////////////
827 // Setting Translations
828 ///////////////////////
829 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
830 0.5*fgkSSDSensorSideSupportWidth,
831 0.0);
832 localssdsensorsupportrans[1][0] =
833 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
834 localssdsensorsupportrans[2][0] =
835 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
836 localssdsensorsupportrans[0][1] =
837 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
838 0.5*fgkSSDSensorSideSupportThickness[0],
839 0.0);
840 localssdsensorsupportrans[1][1] =
841 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
842 - 0.5*fgkSSDSensorSideSupportThickness[0]
843 - fgkSSDModuleSensorSupportDistance,
844 0.0);
845 localssdsensorsupportrans[2][1] =
846 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
847 - fgkSSDSensorCenterSupportPosition,
848 0.5*fgkSSDSensorCenterSupportWidth
849 - 0.5*fgkSSDModuleSensorSupportDistance,
850 fgkSSDSensorCenterSupportThickness[0]);
851 localssdsensorsupportrans[0][2] =
852 new TGeoTranslation(fgkCarbonFiberTriangleLength
853 + fgkCarbonFiberJunctionToSensorSupport,
854 fgkCarbonFiberJunctionWidth
855 - 0.5*(fgkCarbonFiberLowerSupportWidth
856 + fgkSSDSensorCenterSupportLength
857 - fgkSSDSensorCenterSupportThickness[0])
858 - fgkSSDSensorCenterSupportPosition,
859 0.0);
860 localssdsensorsupportrans[1][2] =
861 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
862 localssdsensorsupportrans[2][2] =
863 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
864 ////////////////////
865 // Setting Rotations
866 ////////////////////
867 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
868 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
869 localssdsensorsupportrot[i][j] = new TGeoRotation();
870 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
871 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
872 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 873 }
bf210566 874 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
875 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
876 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
877 ////////////////////////////////////////
878 // SSD Sensor Support matrix
879 ////////////////////////////////////////
880 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
881 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
882 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
883 localssdsensorsupportmatrix[i][j] =
884 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
885 *localssdsensorsupportrot[i][j]);
886 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
887 }
d7599219 888 }
44285dfa 889 /////////////////////////////////////////////////////////////
bf210566 890 // SSD Cooling Tube Support Transformations
44285dfa 891 /////////////////////////////////////////////////////////////
bf210566 892 const Int_t kcoolingtubesupportmatrixnumber = 2;
893 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
894 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
895 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 896 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 897 /fgkCoolingTubeSupportRmax);
bf210566 898 localcoolingtubesupportrans[0] =
899 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 900 + 2.*(fgkCoolingTubeSupportLength
44285dfa 901 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 902 + fgkCarbonFiberTriangleLength
bf210566 903 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
904 localcoolingtubesupportrans[1] =
905 new TGeoTranslation(fgkCarbonFiberJunctionLength
906 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
907 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
908 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
909 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
910 - 0.5*(fgkCarbonFiberLowerSupportWidth
911 + fgkSSDSensorCenterSupportLength
912 - fgkSSDSensorCenterSupportThickness[0])
913 + 0.5*fgkSSDSensorLength,
914 - 0.5*fgkCoolingTubeSupportHeight);
915 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
916 localcoolingtubesupportrot[i] = new TGeoRotation();
917 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
918 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
919 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
920 localcoolingtubesupportmatrix[i] =
921 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
922 *localcoolingtubesupportrot[i]);
923 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
924 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
925 (*localcoolingtubesupportmatrix[0]));
926 /////////////////////////////////////////////////////////////
9b0c60ab 927 // End Ladder SSD Cooling Tube Support Transformations
928 /////////////////////////////////////////////////////////////
929 TGeoTranslation** localendladdercooltubetrans[2];
930 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
931 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
932 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
933 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
934 - (fgkCoolingTubeSupportLength
935 - fgkCoolingTubeSupportRmax),
936 fgkEndLadderMountingBlockPosition[0]
937 - fgkendladdercoolingsupportdistance[0]
938 + 0.5*fgkCoolingTubeSupportWidth,
939 - 0.5*fgkCoolingTubeSupportHeight);
940 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
941 - (fgkCoolingTubeSupportLength
942 - fgkCoolingTubeSupportRmax),
943 fgkEndLadderMountingBlockPosition[0]
944 + fgkendladdercoolingsupportdistance[1]
945 + 0.5*fgkCoolingTubeSupportWidth,
946 - 0.5*fgkCoolingTubeSupportHeight);
947 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
948 - fgkCoolingTubeSupportRmax)
949 + fgkCarbonFiberTriangleLength
950 - 2.0*fgkCarbonFiberJunctionLength,
951 0.0,
952 0.0);
953 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
954 fgkendladdercoolingsupportdistance[0]
955 + fgkendladdercoolingsupportdistance[1],
956 0.0);
957 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
958 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
959 + fgkCarbonFiberJunctionLength
960 - fgkCoolingTubeSupportLength,
961 fgkEndLadderCarbonFiberLowerJunctionLength[1]
962 - 0.5*fgkCoolingTubeSupportWidth
963 -fgkendladdercoolingsupportdistance[2],
964 - 0.5*fgkCoolingTubeSupportHeight);
965 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
966 + fgkCoolingTubeSupportLength
967 - fgkCoolingTubeSupportRmax
968 - fgkCarbonFiberJunctionLength,
969 fgkEndLadderCarbonFiberLowerJunctionLength[1]
970 - 0.5*fgkCoolingTubeSupportWidth
971 - fgkendladdercoolingsupportdistance[2],
972 - 0.5*fgkCoolingTubeSupportHeight);
973 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
974 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
975 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
976 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
977 (*localcoolingtubesupportrot[1]));
978 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
979 (*localcoolingtubesupportrot[1]));
980 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
981 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
982 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
983 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
984 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
985
986 fendladdercoolingtubesupportmatrix[1][0] =
987 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
988 *(*localcoolingtubesupportrot[1]));
989 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
990 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
991 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
992 /////////////////////////////////////////////////////////////
bf210566 993 // SSD Cooling Tube Transformations
994 /////////////////////////////////////////////////////////////
995 TGeoRotation* localcoolingtuberot = new TGeoRotation();
996 localcoolingtuberot->SetAngles(0.,90.,0.);
cd2243fb 997 TGeoTranslation* localcoolingtubetrans[2];
998 TVector3* localcoolingtubevect[2];
999
1000 localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
bf210566 1001 -fgkCarbonFiberTriangleLength),
cd2243fb 1002 fgkCarbonFiberJunctionWidth // Y-coord is local Z, from sensor translation
1003 - fgkCarbonFiberLowerSupportWidth
1004 - fgkLowerSupportToSensorZ ,
bf210566 1005 - 0.5*fgkCoolingTubeSupportHeight);
cd2243fb 1006 localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
1007 localcoolingtubevect[0]->Y(),
1008 localcoolingtubevect[0]->Z());
bf210566 1009 for(Int_t j=0; j<2; j++){
cd2243fb 1010 localcoolingtubetrans[j] =
1011 new TGeoTranslation(localcoolingtubevect[j]->X(),
1012 localcoolingtubevect[j]->Y(),
1013 localcoolingtubevect[j]->Z());
1014 fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j])
bf210566 1015 * (*localcoolingtuberot));
1016 }
1017 /////////////////////////////////////////////////////////////
9b0c60ab 1018 // SSD End Ladder Cooling Tube Transformations
1019 /////////////////////////////////////////////////////////////
1020 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1021 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1022 TGeoTranslation** localendlladdercoolingtubetrans[2];
cd2243fb 1023 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
1024 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
9b0c60ab 1025 for(Int_t i=0; i<2; i++)
cd2243fb 1026 for(Int_t j=0; j<2; j++)
9b0c60ab 1027 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
cd2243fb 1028
1029 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
9b0c60ab 1030 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1031 - fgkCoolingTubeSupportRmax)
1032 + fgkCarbonFiberJunctionLength,
cd2243fb 1033 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
9b0c60ab 1034 - 0.5*fgkCoolingTubeSupportHeight);
1035 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1036 - fgkCoolingTubeSupportRmax)
1037 - fgkCarbonFiberJunctionLength
1038 + fgkCarbonFiberTriangleLength,
cd2243fb 1039 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
9b0c60ab 1040 - 0.5*fgkCoolingTubeSupportHeight);
cd2243fb 1041
9b0c60ab 1042 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
cd2243fb 1043 - fgkCoolingTubeSupportRmax)
1044 + fgkCarbonFiberJunctionLength,
1045 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
9b0c60ab 1046 - 0.5*fgkCoolingTubeSupportHeight);
1047 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1048 - fgkCoolingTubeSupportRmax)
1049 - fgkCarbonFiberJunctionLength
1050 + fgkCarbonFiberTriangleLength,
cd2243fb 1051 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
9b0c60ab 1052 - 0.5*fgkCoolingTubeSupportHeight);
9b0c60ab 1053 for(Int_t i=0; i<2; i++)
cd2243fb 1054 for(Int_t j=0; j<2; j++){
9b0c60ab 1055 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1056 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1057 }
1058 /////////////////////////////////////////////////////////////
bf210566 1059 // SSD Hybrid Components Transformations
1060 /////////////////////////////////////////////////////////////
1061 const Int_t khybridmatrixnumber = 3;
1062 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1063 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1064 0.5*fgkSSDStiffenerWidth,
1065 0.5*fgkSSDStiffenerHeight);
1066 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1067 fgkSSDModuleStiffenerPosition[1],0.0);
1068
1069 localhybridtrans[2] = new TGeoTranslation(
1070 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1071 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1072 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1073 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1074 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1075 - fgkSSDSensorCenterSupportThickness[0]),
1076 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
ca86fdb4 1077 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
0fb26117 1078 - fgkSSDModuleVerticalDisalignment));
bf210566 1079 fhybridmatrix = new TGeoHMatrix();
1080 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1081 /////////////////////////////////////////////////////////////
1082 // SSD Cooling Block Transformations
1083 /////////////////////////////////////////////////////////////
1084 const Int_t kcoolingblockmatrixnumber = 4;
1085 TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
1086 localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
1087 - fgkCoolingTubeSupportRmin),0.0,
1088 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1089 localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
1090 - 0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
1091 0.0,fgkSSDStiffenerHeight);
1092 localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
1093 localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
1094 fcoolingblocksystematrix = new TGeoHMatrix();
1095 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
1096 fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
1097 /////////////////////////////////////////////////////////////
1098 // SSD Stiffener Flex Transformations
1099 /////////////////////////////////////////////////////////////
1100 const Int_t klocalflexmatrixnumber = 4;
1101 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1102 for(Int_t i=0; i<fgkflexnumber; i++)
1103 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1104 for(Int_t i=0; i<fgkflexnumber; i++)
1105 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1106 localflexmatrix[i][j] = new TGeoCombiTrans();
1107 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1108 - 2.*fgkSSDModuleStiffenerPosition[1]
1109 - fgkSSDStiffenerWidth;
1110 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1111 +0.5*fgkSSDStiffenerLength,
1112 0.5*fgkSSDStiffenerWidth,
1113 -0.5*fgkSSDStiffenerHeight
1114 -0.5*fgkSSDFlexHeight[0]);
1115 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1116 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1117 -0.5*fgkSSDStiffenerWidth,
1118 -0.5*fgkSSDStiffenerHeight
1119 -0.5*fgkSSDFlexHeight[0]);
1120 TGeoRotation* localflexrot = new TGeoRotation();
1121 localflexrot->SetAngles(180.,0.,0.);
1122 localflexmatrix[1][0]->SetRotation(localflexrot);
1123 for(Int_t i=0; i<fgkflexnumber; i++)
1124 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1125 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1126 for(Int_t i=0; i<fgkflexnumber; i++){
1127 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1128 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1129 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1130 }
bf210566 1131 /////////////////////////////////////////////////////////////
1132 // SSD End Flex Transformations
1133 /////////////////////////////////////////////////////////////
1134 TGeoRotation* localendflexrot = new TGeoRotation();
1135 localendflexrot->SetAngles(0.0,90.0,0.0);
1136 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1137 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1138 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1139 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1140 * TMath::DegToRad()*ssdflexradiusmax
1141 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 1142 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1143 - 0.1*fgkSSDFlexFullLength;
bf210566 1144 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1145 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1146 + fgkSSDFlexLength[2];
1147 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1148 0.5*fgkSSDFlexWidth[0],
1149 2.*fgkSSDStiffenerHeight
1150 + 0.5*fgkSSDFlexHeight[0]);
1151 localendflexmatrix->SetRotation(localendflexrot);
1152 for(Int_t i=0; i<fgkflexnumber; i++)
1153 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1154 /////////////////////////////////////////////////////////////
1155 // End Ladder Carbon Fiber Junction
1156 /////////////////////////////////////////////////////////////
1157 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1158 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1159 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1160 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1161 localendladdercarbonfiberjunctionmatrix[i]
1162 = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1163 localendladdercarbonfiberjunctionrot[i]
1164 = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1165 localendladdercarbonfiberjunctiontrans[i]
1166 = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1167 fendladdercarbonfiberjunctionmatrix[i]
1168 = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
d7599219 1169 }
bf210566 1170 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1171 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1172 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1173 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1174 }
1175 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1176 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1177 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1178 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1179 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1180 0.0,0.0);
1181 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1182 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1183 * SinD(fgkCarbonFiberTriangleAngle),
1184 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1185 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1186 }
1187 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1188 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1189 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1190 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1191 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1192 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1193 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1194 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1195 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1196 localendladdercarbonfiberjunctionglobalmatrix[i] =
1197 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1198 *localendladdercarbonfiberjunctionglobalrot[i]);
1199 }
1200 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1201 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1202 localendladdercarbonfiberjunctionmatrix[i][j] =
1203 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1204 *localendladdercarbonfiberjunctionrot[i][j]);
1205 fendladdercarbonfiberjunctionmatrix[i][j] =
1206 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1207 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1208 }
1209 /////////////////////////////////////////////////////////////
1210 // End Ladder Carbon Fiber Support
1211 /////////////////////////////////////////////////////////////
1212 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1213 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1214 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1215 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1216 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1217 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1218 }
1219 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1220 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1221 fendladdercarbonfibermatrix[i][j] =
1222 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1223 *(*fcarbonfibersupportmatrix[j]));
1224 /////////////////////////////////////////////////////////////
1225 // End Ladder SSD Mounting Block
1226 /////////////////////////////////////////////////////////////
1227 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1228 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1229 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1230 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1231 + fgkSSDMountingBlockLength[1])
1232 + 0.5*fgkCarbonFiberTriangleLength,
1233 fgkEndLadderMountingBlockPosition[i],
1234 - fgkSSDMountingBlockHeight[1]
1235 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1236 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1237 endladdermountingblockrot->SetAngles(0.,90.,0.);
1238 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1239 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1240 /////////////////////////////////////////////////////////////
1241 // End Ladder SSD Mounting Block Clip Matrix
1242 /////////////////////////////////////////////////////////////
1243 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1244 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1245
1246 TGeoRotation* localendladdercliprot = new TGeoRotation();
1247 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1248 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1249 - fgkSSDMountingBlockLength[1])
1250 + fgkSSDMountingBlockLength[0],0.,0.);
1251 localendladdercliprot->SetAngles(90.,180.,-90.);
1252 TGeoCombiTrans* localendladderclipcombitrans =
1253 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1254 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1255 for(Int_t j=0; j<2; j++){
1256 fendladdermountingblockclipmatrix[i][j] =
1257 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1258 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1259 }
bf210566 1260 /////////////////////////////////////////////////////////////
1261 // End Ladder Carbon Fiber Lower Support
1262 /////////////////////////////////////////////////////////////
1263 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1264 fendladderlowersupptrans[i] =
1265 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1266 + 0.5*fgkSSDMountingBlockWidth),
1267 - 0.5*fgkCarbonFiberLowerSupportHeight);
1268 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1269 fgkCarbonFiberLowerSupportVolumePosition[1]
1270 + fgkCarbonFiberLowerSupportVolumePosition[0],
1271 0.0);
1272 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1273 /////////////////////////////////////////////////////////////
1274 // Matrix for positioning Ladder into mother volume
1275 /////////////////////////////////////////////////////////////
1276 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1277 for(Int_t i=0; i<fgkladdernumber; i++)
1278 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1279 TGeoRotation* localladdermotherrot = new TGeoRotation();
1280 localladdermotherrot->SetAngles(0.,90.,0.);
1281 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1282 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1283 for(Int_t i=0; i<fgkladdernumber; i++){
1284 localladdermothertrans[i] = new TGeoTranslation(0.,
1285 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1286 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1287 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1288 * fgkCarbonFiberJunctionWidth,0.);
1289 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1290 *localladdermotherrot);
1291 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1292 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1293 }
44285dfa 1294 /////////////////////////////////////////////////////////////
bf210566 1295 // Ladder Cables Matrices
44285dfa 1296 /////////////////////////////////////////////////////////////
44285dfa 1297 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1298 + fgkSSDFlexHeight[1];
44285dfa 1299 Double_t ssdladdercabletransx[3];
1300 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1301 * SinD(2.*fgkSSDFlexAngle)
1302 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1303 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1304 - ssdladdercabletransx[0]
bf210566 1305 / SinD(2.*fgkSSDFlexAngle))
1306 * CosD(fgkSSDFlexAngle);
44285dfa 1307 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1308 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1309 - fgkSSDFlexLength[2]-TMath::Pi()
1310 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1311 - fgkSSDLadderCableWidth)
bf210566 1312 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1313 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1314 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1315 ssdladdercabletransx[1]
bf210566 1316 * TanD(fgkSSDFlexAngle),
44285dfa 1317 ssdladdercabletransx[2]
bf210566 1318 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1319 TGeoRotation* localladdercablerot[3];
bf210566 1320 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1321 localladdercablerot[0]->SetAngles(90.,0.,0.);
1322 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1323 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1324 * (*localladdercablerot[0]));
cd2243fb 1325 //TGeoRotation* localladdercablerot = new TGeoRotation();
1326 //localladdercablerot->SetAngles(90.,0.,0.);
44285dfa 1327 ////////////////////////////////////////////
1328 // LocalLadderCableCombiTransMatrix
1329 ////////////////////////////////////////////
1330 const Int_t klocalladdersidecablesnumber = 2;
1331 const Int_t klocalladdercombitransnumber = 5;
1332 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1333 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1334 localladdercablecombitransmatrix[i] =
1335 new TGeoCombiTrans*[klocalladdercombitransnumber];
1336 ///////////////////////////////////////////
1337 // Left Side Ladder Cables Transformations
1338 ///////////////////////////////////////////
1339 localladdercablecombitransmatrix[0][0] =
d7599219 1340 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1341 0.,0.,NULL);
bf210566 1342 localladdercablecombitransmatrix[0][1] =
1343 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1344 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1345 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1346 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1347 - 0.5*(fgkCarbonFiberLowerSupportWidth
1348 + fgkSSDSensorCenterSupportLength
1349 - fgkSSDSensorCenterSupportThickness[0]),
1350 - (fgkSSDModuleCoolingBlockToSensor
1351 + 0.5*fgkCoolingTubeSupportHeight
1352 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1353 - fgkSSDChipHeight),NULL);
44285dfa 1354 localladdercablecombitransmatrix[0][2] =
d7599219 1355 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1356 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1357 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1358 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1359 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1360 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1361 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1362 new TGeoRotation("",180.,0.,0.));
44285dfa 1363 localladdercablecombitransmatrix[0][4] =
1364 new TGeoCombiTrans(-ssdladdercabletransx[0]
1365 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1366 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1367 0.,
1368 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1369 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1370 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1371 + ssdladdercabletransz[2],localladdercablerot[2]);
1372 ///////////////////////////////////////////
1373 // Rigth Side Ladder Cables Transformations
1374 ///////////////////////////////////////////
bf210566 1375 TGeoCombiTrans* localladdercablessdmodulematrix =
1376 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1377 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1378 fgkSSDStiffenerWidth,
1379 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1380 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1381 localladdercablecombitransmatrix[1][i] =
bf210566 1382 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1383 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1384 ///////////////////////////////////////////
bf210566 1385 // Setting LadderCableHMatrix
44285dfa 1386 ///////////////////////////////////////////
bf210566 1387 Int_t beamaxistrans[2][3];
1388 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1389 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1390 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1391 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1392 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1393 beamaxistrans[1][2] = beamaxistrans[1][0];
1394 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1395 TGeoRotation* laddercablerot = new TGeoRotation();
1396 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1397 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1398 Double_t* laddercabletransvector;
1399 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1400 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1401 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1402 }
1403 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1404 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1405 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1406 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1407 localladdercablehmatrix[i][j]->MultiplyLeft(
1408 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1409 }
1410 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1411 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1412 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1413 laddercabletransvector[1]
bf210566 1414 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1415 * fgkCarbonFiberJunctionWidth,
bf210566 1416 laddercabletransvector[2]);
1417 laddercablecombitrans->SetRotation(*laddercablerot);
1418 laddercablecombitrans->SetTranslation(*laddercabletrans);
1419 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1420 }
1421 fladdercablematrix[i][2] =
1422 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1423 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1424 fladdercablematrix[i][3] =
1425 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1426 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1427 }
1428 for(Int_t i=0; i<fgkladdercablesnumber; i++)
1429 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1430 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1431 ///////////////////////////////////////////
1432 // Setting Ladder HMatrix
1433 ///////////////////////////////////////////
1434 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1435 fgkSSDLay6SensorsNumber};
1436 for(Int_t i=0; i<fgkladdernumber; i++){
1437 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1438 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1439 fladdermatrix[i][j] = new TGeoHMatrix();
1440 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1441 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1442 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1443 }
1444 }
1445 ///////////////////////////////////////////
1446 // Setting SSD Sensor Matrix
1447 ///////////////////////////////////////////
1448 TGeoCombiTrans* localssdsensorcombitrans[2];
1449 TGeoRotation* localssdsensorrot = new TGeoRotation();
1450 localssdsensorrot->SetAngles(0.,90.,0.);
1451 TGeoTranslation* localssdsensortrans[2];
1452 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1453 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1454 fgkCarbonFiberJunctionWidth
1455 - fgkCarbonFiberLowerSupportWidth
1456 - fgkLowerSupportToSensorZ,
bf210566 1457 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1458 - fgkSSDModuleCoolingBlockToSensor
e21cdd03 1459 + (fgkSSDSensorSideSupportHeight[1]
0fb26117 1460 - fgkSSDSensorSideSupportHeight[0]));
bf210566 1461 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1462 fgkCarbonFiberJunctionWidth
1463 - fgkCarbonFiberLowerSupportWidth
1464 - fgkLowerSupportToSensorZ,
bf210566 1465 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1466 -fgkSSDModuleCoolingBlockToSensor);
cd2243fb 1467
bf210566 1468 for(Int_t i=0; i<2; i++)
1469 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1470 *localssdsensorrot);
1471 for(Int_t i=0; i<fgkladdernumber; i++){
1472 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1473 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1474 switch(i){
1475 case 0: //Ladder of Layer5
1476 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1477 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1478 *localssdsensorcombitrans[1])));
1479 break;
1480 case 1: //Ladder of Layer6
1481 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1482 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1483 *localssdsensorcombitrans[0])));
1484 break;
1485 }
1486 }
1487 }
1488 //////////////////////////
1489 // Setting SSD End Ladder
1490 //////////////////////////
1491 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1492 for(Int_t i=0; i<2; i++){
1493 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1494 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1495 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1496 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1497 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1498 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1499 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1500 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1501 }
1502 /////////////////////////////////////////////////////
1503 // Setting the CombiTransformation to pass ITS center
1504 /////////////////////////////////////////////////////
1505 Double_t itscentertransz[fgklayernumber];
1506 itscentertransz[0] = fgkSSDLay5LadderLength
1507 - fgkLay5CenterITSPosition;
1508 itscentertransz[1] = fgkSSDLay6LadderLength
1509 - fgkLay6CenterITSPosition;
1510 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1511 + 0.5*fgkCoolingTubeSupportHeight;
1512 TGeoRotation* itscenterrot[3];
1513 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1514 itscenterrot[0]->SetAngles(90.,180.,-90.);
1515 itscenterrot[1]->SetAngles(0.,90.,0.);
1516 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1517 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1518 for(Int_t i=0; i<fgklayernumber; i++)
1519 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1520 itssensortransy,
1521 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1522 - itscentertransz[i],itscenterrot[2]);
1523 TGeoRotation** locallayerrot[fgklayernumber];
1524 TGeoTranslation** locallayertrans[fgklayernumber];
1525 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1526 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1527 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1528 - fgkLay5CenterITSPosition);
1529 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1530 - fgkLay6CenterITSPosition);
1531 const Int_t kssdlayladdernumber[fgklayernumber] =
1532 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1533 for(Int_t i=0; i<fgklayernumber; i++){
1534 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1535 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1536 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1537 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1538 }
1539 Double_t layerladderangleposition[fgklayernumber] =
1540 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1541 Double_t layerradius = 0.;
1542 for(Int_t i=0; i<fgklayernumber; i++){
1543 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1544 switch(i){
1545 case 0: //Ladder of Layer5
1546 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1547 break;
1548 case 1: //Ladder of Layer6
1549 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1550 break;
1551 }
1552 locallayerrot[i][j] = new TGeoRotation();
1553 locallayertrans[i][j] = new TGeoTranslation();
1554 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1555 locallayertrans[i][j]->SetTranslation(layerradius
1556 * CosD(90.0+j*layerladderangleposition[i]),
1557 layerradius
1558 * SinD(90.0+j*layerladderangleposition[i]),0.);
1559 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1560 *locallayerrot[i][j]);
1561 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1562 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1563 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1564 }
1565 }
44285dfa 1566 /////////////////////////////////////////////////////////////
bf210566 1567 // Deallocating memory
44285dfa 1568 /////////////////////////////////////////////////////////////
bf210566 1569 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1570 delete carbonfiberot[i];
1571 delete localcarbonfibersupportmatrix[i];
1572 }
1573 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1574 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1575 delete localcarbonfiberjunctionmatrix[i][j];
1576 delete localcarbonfiberjunctionrot[i][j];
1577 delete localcarbonfiberjunctiontrans[i][j];
1578 }
1579 delete [] localcarbonfiberjunctionmatrix[i];
1580 delete [] localcarbonfiberjunctionrot[i];
1581 delete [] localcarbonfiberjunctiontrans[i];
1582 }
1583 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1584 delete localcarbonfiberlowersupportrans[i];
1585 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1586 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1587 delete localssdsensorsupportmatrix[i][j];
1588 delete localssdsensorsupportrot[i][j];
1589 delete localssdsensorsupportrans[i][j];
1590 }
1591 delete [] localssdsensorsupportmatrix[i];
1592 delete [] localssdsensorsupportrot[i];
1593 delete [] localssdsensorsupportrans[i];
1594 }
1595 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1596 delete localcoolingtubesupportmatrix[i];
1597 delete localcoolingtubesupportrot[i];
1598 delete localcoolingtubesupportrans[i];
1599 }
cd2243fb 1600 for(Int_t j=0; j<2; j++){
1601 delete localcoolingtubevect[j];
1602 delete localcoolingtubetrans[j];
bf210566 1603 }
9b0c60ab 1604 delete endladdermountingblockrot;
bf210566 1605 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1606 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
1607 for(Int_t i=0; i<fgkflexnumber; i++){
1608 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1609 delete localflexmatrix[i][j];
1610 delete [] localflexmatrix[i];
1611 }
9b0c60ab 1612 delete localendlladdercoolingtuberot;
1613 for(Int_t i=0; i<2; i++){
cd2243fb 1614 for(Int_t j=0; j<2; j++)
1615 delete localendlladdercoolingtubetrans[i][j];
9b0c60ab 1616 delete [] localendlladdercoolingtubetrans[i];
1617 }
1618
bf210566 1619 delete localflexrot;
1620 delete localendflexrot;
1621 delete localendflexmatrix;
1622 for(Int_t i=0; i<fgkladdernumber; i++){
1623 delete localladdermothertrans[i];
1624 delete localladdermothercombitrans[i];
1625 }
1626 delete localladdermotherrot;
1627 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1628 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1629 delete localendladdercarbonfiberjunctionmatrix[i][j];
1630 delete localendladdercarbonfiberjunctionrot[i][j];
1631 delete localendladdercarbonfiberjunctiontrans[i][j];
1632 }
1633 delete [] localendladdercarbonfiberjunctionmatrix[i];
1634 delete [] localendladdercarbonfiberjunctionrot[i];
1635 delete [] localendladdercarbonfiberjunctiontrans[i];
1636 delete localendladdercarbonfiberjunctionglobalrot[i];
1637 delete localendladdercarbonfiberjunctionglobaltrans[i];
1638 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1639 }
9b0c60ab 1640 for(Int_t i=0; i<2; i++){
1641 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1642 delete [] localendladdercooltubetrans[i];
1643 }
1644 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1645 delete localendladdercarbonfibertrans[i];
1646 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1647 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1648 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1649 delete localladdercablecombitransmatrix[i][j];
1650 delete []localladdercablecombitransmatrix[i];
1651 }
9b0c60ab 1652 delete localendladdercliprot;
1653 delete localendladdercliptrans;
bf210566 1654 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1655 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1656 delete localladdercablehmatrix[i][j];
1657 delete []localladdercablehmatrix[i];
1658 }
1659 delete laddercablerot;
1660 delete laddercabletrans;
1661 delete laddercablecombitrans;
1662 delete localladdercablessdmodulematrix;
1663 delete localssdsensorrot;
1664 for(Int_t i=0; i<2; i++){
1665 delete localssdsensortrans[i];
1666 delete localssdsensorcombitrans[i];
1667 }
1668 for(Int_t i=0; i<fgklayernumber; i++){
1669 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1670 delete locallayerrot[i][j];
1671 delete locallayertrans[i][j];
1672 delete locallayercombitrans[i][j];
1673 }
1674 delete [] locallayerrot[i];
1675 delete [] locallayertrans[i];
1676 delete [] locallayercombitrans[i];
1677 delete localbeamaxistrans[i];
1678 }
1679 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1680 for(Int_t i=0; i<fgkladdernumber; i++){
1681 for(Int_t j=0; j<fgkladdernumber; j++)
1682 delete ladderglobalmatrix[i][j];
1683 delete [] ladderglobalmatrix[i];
1684 }
1685 /////////////////////////////////////////////////////////////
1686 fTransformationMatrices = kTRUE;
d7599219 1687}
bf210566 1688///////////////////////////////////////////////////////////////////////////////
1689void AliITSv11GeometrySSD::CreateBasicObjects(){
1690 /////////////////////////////////////////////////////////////
1691 // Method generating the Objects of SSD Geometry
1692 /////////////////////////////////////////////////////////////
1693 // SSD Sensor
1694 ///////////////////////////////////
1695 SetSSDSensor();
1696 /////////////////////////////////////////////////////////////
1697 // Carbon Fiber Support
1698 /////////////////////////////////////////////////////////////
1699 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1700 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1701 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1702 /////////////////////////////////////////////////////////////
bf210566 1703 // Carbon Fiber Junction
44285dfa 1704 /////////////////////////////////////////////////////////////
ca86fdb4 1705 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
bf210566 1706 /////////////////////////////////////////////////////////////
1707 // Carbon Fiber Lower Support
1708 /////////////////////////////////////////////////////////////
1709 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1710 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1711 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1712 /////////////////////////////
1713 // SSD Sensor Support
1714 /////////////////////////////
1715 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1716 new TGeoVolume*[fgkssdsensorsupportnumber];
44285dfa 1717 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
bf210566 1718 fgkSSDSensorSideSupportThickness[1]};
1719 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1720 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1721 fgkSSDSensorSideSupportHeight[i],
1722 fgkSSDSensorSideSupportWidth,
1723 sidesupporthickness);
1724 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1725 fgkSSDSensorCenterSupportHeight[i],
1726 fgkSSDSensorCenterSupportWidth,
1727 sidesupporthickness);
1728 }
1729 /////////////////////////////////////////////////////////////
1730 // SSD Cooling Tube Support
1731 /////////////////////////////////////////////////////////////
3c057f23 1732 Int_t edgesnumber = 3;
bf210566 1733 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1734 /////////////////////////////////////////////////////////////
1735 // SSD Hybrid
1736 /////////////////////////////////////////////////////////////
1737 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1738 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1739 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1740 /////////////////////////////////////////////////////////////
1741 // SSD Cooling Block System
1742 /////////////////////////////////////////////////////////////
1743 fssdcoolingblocksystem = GetCoolingBlockSystem();
1744 /////////////////////////////////////////////////////////////
1745 // SSD Cooling Tube
1746 /////////////////////////////////////////////////////////////
cd2243fb 1747 CreateCoolingTubes();
bf210566 1748 /////////////////////////////////////////////////////////////
1749 // SSD Flex
1750 /////////////////////////////////////////////////////////////
1751 fssdstiffenerflex = GetSSDStiffenerFlex();
1752 fssdendflex = GetSSDEndFlex();
1753 ///////////////////////////////////
1754 // End Ladder Carbon Fiber Junction
1755 ///////////////////////////////////
1756 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1757 fendladdercarbonfiberjunction[i] =
1758 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1759 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1760 fendladdercarbonfiberjunction[i][0] =
ca86fdb4 1761 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
bf210566 1762 fendladdercarbonfiberjunction[i][1] =
ca86fdb4 1763 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
bf210566 1764 }
1765 ///////////////////////////////////
1766 // End Ladder Mounting Block
1767 ///////////////////////////////////
1768 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1769 ///////////////////////////////////
1770 // End Ladder Mounting Block
1771 ///////////////////////////////////
1772 fendladdermountingblockclip = GetMountingBlockClip();
1773 ///////////////////////////////////
1774 // Ladder Support
1775 ///////////////////////////////////
1776 TList* laddersupportlist = GetMountingBlockSupport(20);
1777 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1778 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1779 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1780 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
bf210566 1781 /////////////////////////////////////////////////////////////
1782 // Deallocating memory
44285dfa 1783 /////////////////////////////////////////////////////////////
bf210566 1784 delete carbonfibersupportlist;
1785 delete carbonfiberlowersupportlist;
1786 delete ssdhybridcomponentslist;
9b0c60ab 1787 delete laddersupportlist;
44285dfa 1788 /////////////////////////////////////////////////////////////
bf210566 1789 fBasicObjects = kTRUE;
1790}
1791/////////////////////////////////////////////////////////////////////////////////
1792void AliITSv11GeometrySSD::SetSSDSensor(){
1793 ////////////////////////////////////////////////////////////////
1794 // Method generating SSD Sensors: it sets the private variables
1795 // fSSDSensor5, fSSDSensor6
1796 ////////////////////////////////////////////////////////////////
44285dfa 1797 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1798 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1799 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
44285dfa 1800 0.5*ssdsensitivewidth,
bf210566 1801 0.5*fgkSSDSensorHeight,
1802 0.5*ssdsensitivelength);
1803 TGeoVolume* ssdsensorsensitiveLay5 =
02d4acf9 1804 new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1805 TGeoVolume* ssdsensorsensitiveLay6 =
02d4acf9 1806 new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1807 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1808 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
44285dfa 1809 TGeoBBox* ssdsensorinsensitiveshape[2];
1810 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1811 0.5*fgkSSDSensorInsensitiveWidth,
bf210566 1812 0.5*fgkSSDSensorHeight,
1813 0.5*fgkSSDSensorLength);
44285dfa 1814 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
44285dfa 1815 0.5*ssdsensitivewidth,
bf210566 1816 0.5*fgkSSDSensorHeight,
1817 0.5*fgkSSDSensorInsensitiveWidth);
44285dfa 1818 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1819 "SSDSensorInsensitive2"};
44285dfa 1820 TGeoVolume* ssdsensorinsensitive[2];
1821 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1822 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1823 fSSDSensorMedium);
1824 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1825 }
bf210566 1826 /////////////////////////////////////////////////////////////
1827 // Virtual Volume containing SSD Sensor
1828 /////////////////////////////////////////////////////////////
1829 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1830 0.5*fgkSSDSensorWidth,
1831 0.5*fgkSSDSensorHeight,
1832 0.5*fgkSSDSensorLength);
ef9451a3 1833 fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
bf210566 1834 fSSDAir);
ef9451a3 1835 fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
bf210566 1836 fSSDAir);
1837 /////////////////////////////////////////////////////////////
1838 for(Int_t i=0; i<4; i++){
1839 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1840 ssdsensorinsensitive[1],i<2?1:2,
1841 new TGeoTranslation(
1842 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1843 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1844 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1845 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1846 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
44285dfa 1847 ssdsensorinsensitive[1],i<2?1:2,
bf210566 1848 new TGeoTranslation(
1849 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1850 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1851 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1852 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1853 }
1854 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1855 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1856}
bf210566 1857///////////////////////////////////////////////////////////////////////////////
1858TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1859 /////////////////////////////////////////////////////////////
1860 // Method generating the Carbon Fiber Support
1861 /////////////////////////////////////////////////////////////
1862 const Int_t kvertexnumber = 4;
1863 const Int_t kshapesnumber = 2;
1864 TVector3** vertexposition[kshapesnumber];
1865 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1866 Double_t carbonfibersupportxaxisEdgeproj =
1867 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1868 * TMath::DegToRad());
1869 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1870 / fgkCarbonFiberSupportXAxisLength);
1871 /////////////////////
1872 //Vertex Positioning
1873 ////////////////////
1874 vertexposition[0][0] = new TVector3();
1875 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1876 fgkCarbonFiberSupportYAxisLength);
1877 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1878 carbonfibersupportxaxisEdgeproj
1879 * TMath::Tan(theta));
1880 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1881 - carbonfibersupportxaxisEdgeproj,
1882 fgkCarbonFiberSupportYAxisLength
1883 - vertexposition[0][2]->Y());
1884 ////////////////////////////////////////////////////
1885 //Setting the parameters for Isometry Transformation
1886 ////////////////////////////////////////////////////
1887 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1888 + fgkCarbonFiberSupportTopEdgeDist[0]
1889 + fgkCarbonFiberSupportWidth);
1890 Double_t* param = new Double_t[4];
1891 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1892 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
160835d5 1893 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1894 (GetReflection(vertexposition[0][j],param))->Y());
a6e0ebfe 1895 const char* carbonfibersupportshapename[kshapesnumber] =
bf210566 1896 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
a6e0ebfe 1897 const char* carbonfibersupportname[kshapesnumber] =
bf210566 1898 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1899 TGeoArb8* carbonfibersupportshape[kshapesnumber];
1900 TGeoVolume* carbonfibersupport[kshapesnumber];
1901 TList* carbonfibersupportlist = new TList();
1902 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1903 Double_t carbonfibersupportheight =
1904 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1905 *TMath::DegToRad());
1906 for(Int_t i = 0; i< kshapesnumber; i++){
1907 carbonfibersupportshape[i] =
1908 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1909 carbonfibersupportshapename[i],i==0 ? 1: -1);
1910 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1911 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1912 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1913 carbonfibersupportlist->Add(carbonfibersupport[i]);
1914 }
1915 /////////////////////////////////////////////////////////////
1916 // Deallocating memory
1917 /////////////////////////////////////////////////////////////
1918 for(Int_t i=0; i< kshapesnumber; i++){
1919 for(Int_t j=0; j< kvertexnumber; j++)
1920 delete vertexposition[i][j];
1921 delete [] vertexposition[i];
1922 }
1923 delete [] param;
44285dfa 1924 /////////////////////////////////////////////////////////////
bf210566 1925 return carbonfibersupportlist;
d7599219 1926}
1927/////////////////////////////////////////////////////////////////////////////////
bf210566 1928TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 1929 /////////////////////////////////////////////////////////////
bf210566 1930 // Method generating SSD Carbon Fiber Junction
44285dfa 1931 /////////////////////////////////////////////////////////////
bf210566 1932 const Int_t kvertexnumber = 6;
1933 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
d4ff3e0a 1934 Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1935 * TMath::DegToRad()),-1.,0.,0.};
bf210566 1936 TVector3* vertex[kvertexnumber];
1937 vertex[0] = new TVector3();
1938 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
1939 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1940 * TMath::DegToRad()),
1941 fgkCarbonFiberJunctionEdge[0]
1942 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
1943 * TMath::DegToRad()));
1944 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
1945 fgkCarbonFiberJunctionEdge[1]);
1946 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
1947 vertex[1] = GetReflection(vertex[5],reflectionparam);
1948 vertex[2] = GetReflection(vertex[4],reflectionparam);
1949 Double_t xvertexpoints[6], yvertexpoints[6];
1950 for(Int_t i=0; i<kvertexnumber; i++)
1951 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
1952 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
1953 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
1954 carbonfiberjunctionshape->DefineSection(1,0.5*width);
1955 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
1956 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
1957 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
1958 /////////////////////////////////////////////////////////////
1959 // Deallocating memory
1960 /////////////////////////////////////////////////////////////
1961 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
1962 /////////////////////////////////////////////////////////////
1963 return carbonfiberjunction;
1964}
1965////////////////////////////////////////////////////////////////////////////////
1966TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
1967 /////////////////////////////////////////////////////////////
1968 // Method generating the Carbon Fiber Lower Support
1969 /////////////////////////////////////////////////////////////
1970 const Int_t kvertexnumber = 4;
1971 const Int_t kshapesnumber = 2;
1972 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
1973 fgkCarbonFiberLowerSupportWidth};
1974 TVector3** vertexposition[kshapesnumber];
1975 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
1976 new TVector3*[kvertexnumber];
1977 //First Shape Vertex Positioning
1978 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
1979 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
1980 - fgkCarbonFiberLowerSupportLowerLenght);
1981 vertexposition[0][2] = new TVector3();
1982 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
1983 //Second Shape Vertex Positioning
1984 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
1985 - fgkCarbonFiberLowerSupportVolumePosition[0])
1986 / fgkCarbonFiberTriangleLength);
1987 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
1988 vertexposition[0][0]->X()*TMath::Tan(theta)
1989 + fgkCarbonFiberLowerSupportVolumePosition[0]);
1990 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
1991 vertexposition[0][1]->X()*TMath::Tan(theta)
1992 + fgkCarbonFiberLowerSupportVolumePosition[0]);
1993 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
1994 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
1995 fgkCarbonFiberLowerSupportVolumePosition[1]);
a6e0ebfe 1996 const char* carbonfiberlowersupportshapename[kshapesnumber] =
bf210566 1997 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
a6e0ebfe 1998 const char* carbonfiberlowersupportname[kshapesnumber] =
bf210566 1999 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2000 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2001 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2002 TList* carbonfiberlowersupportlist = new TList();
2003 for(Int_t i = 0; i< kshapesnumber; i++){
2004 carbonfiberlowersupportshape[i] =
2005 GetArbShape(vertexposition[i],width,
2006 fgkCarbonFiberLowerSupportHeight,
2007 carbonfiberlowersupportshapename[i]);
2008 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2009 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2010 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2011 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2012 }
2013 /////////////////////////////////////////////////////////////
2014 // Deallocating memory
2015 /////////////////////////////////////////////////////////////
2016 for(Int_t i=0; i< kshapesnumber; i++){
2017 for(Int_t j=0; j< kvertexnumber; j++)
2018 delete vertexposition[i][j];
2019 delete [] vertexposition[i];
2020 }
2021 /////////////////////////////////////////////////////////////
2022 return carbonfiberlowersupportlist;
2023}
2024///////////////////////////////////////////////////////////////////////////////
2025TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2026 Double_t width, Double_t* thickness)const{
2027 /////////////////////////////////////////////////////////////
2028 // Method generating the Sensor Support
2029 /////////////////////////////////////////////////////////////
2030 const Int_t kvertexnumber = 6;
2031 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2032 TVector3* vertexposition[kvertexnumber];
2033 vertexposition[0] = new TVector3();
2034 vertexposition[1] = new TVector3(0.0,length);
2035 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2036 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2037 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2038 vertexposition[5] = new TVector3(vertexposition[4]->X());
2039 Double_t xvertexpoints[6], yvertexpoints[6];
2040 for(Int_t i=0; i<kvertexnumber; i++)
2041 xvertexpoints[i] = vertexposition[i]->X(),
2042 yvertexpoints[i] = vertexposition[i]->Y();
2043 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2044 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2045 ssdsensorsupportshape->DefineSection(1,0.5*width);
2046 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2047 ssdsensorsupportshape,fSSDSensorSupportMedium);
2048 /////////////////////////////////////////////////////////////
2049 // Deallocating memory
2050 /////////////////////////////////////////////////////////////
2051 for (Int_t i=0; i<kvertexnumber; i++)
2052 delete vertexposition[i];
2053 /////////////////////////////////////////////////////////////
2054 return ssdsensorsupport;
2055}
2056////////////////////////////////////////////////////////////////////////////////
2057TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2058 /////////////////////////////////////////////////////////////
2059 // Method generating the Cooling Tube Support
2060 /////////////////////////////////////////////////////////////
2061 if(nedges%2!=0) nedges--;
2062 const Int_t kvertexnumber = nedges+5;
2063 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2064 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2065 Double_t angle = 90.+phi;
2066 Double_t psi = 90.-phi;
2067 ///////////////////////////////////////
2068 // Vertex Positioning for TGeoXTru
2069 ///////////////////////////////////////
2070 TVector3** vertexposition = new TVector3*[kvertexnumber];
cd2243fb 2071
3c057f23 2072 Double_t Router = fgkCoolingTubeSupportRmin/CosD(phi/nedges); // Recalc inner radius so that tube fits inside
cd2243fb 2073 vertexposition[0] = new TVector3(Router*CosD(angle),
2074 Router*SinD(angle));
bf210566 2075 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2076 fgkCoolingTubeSupportRmax*SinD(angle));
2077 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2078 fgkCoolingTubeSupportRmax);
2079 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2080 fgkCoolingTubeSupportRmax);
2081 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2082 vertexposition[1]->Y());
cd2243fb 2083
bf210566 2084 for(Int_t i=0; i<nedges; i++)
2085 vertexposition[i+5] =
cd2243fb 2086 new TVector3(Router*CosD(psi+i*(2.*phi/nedges)),
2087 Router*SinD(psi+i*(2.*phi/nedges)));
bf210566 2088 ///////////////////////////////////////////////////////////////////////
2089 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2090 ///////////////////////////////////////////////////////////////////////
2091 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2092 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2093 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2094 for(Int_t i=0; i<kvertexnumber; i++){
2095 xvertexpoints[i] = vertexposition[i]->X();
2096 yvertexpoints[i] = vertexposition[i]->Y();
2097 }
2098 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2099 yvertexpoints);
2100 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2101 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2102 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2103 coolingtubesupportarcshape,
2104 fSSDTubeHolderMedium);
2105 coolingtubesupportarc->SetLineColor(fColorG10);
2106 //////////////////////////////////////////////////////////////////////////
2107 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2108 //////////////////////////////////////////////////////////////////////////
2109 TGeoTubeSeg* coolingtubesupportsegshape =
2110 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2111 fgkCoolingTubeSupportRmax,
2112 0.5*fgkCoolingTubeSupportWidth,
2113 phi,360-phi);
2114 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2115 coolingtubesupportsegshape,
2116 fSSDTubeHolderMedium);
2117 coolingtubesupportseg->SetLineColor(fColorG10);
2118 //////////////////////////////////////////////////////////////////////////
2119 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2120 //////////////////////////////////////////////////////////////////////////
2121 Double_t* boxorigin = new Double_t[3];
2122 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2123 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2124 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2125 0.5*fgkCoolingTubeSupportHeight,
2126 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2127 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2128 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2129 coolingtubesupportbox->SetLineColor(fColorG10);
2130 //////////////////////////////////////////////////////////////////////////
2131 // Cooling Tube for Cooling Tube Support
2132 //////////////////////////////////////////////////////////////////////////
2133 TGeoXtru* coolingtubearcshape[2];
2134 coolingtubearcshape[0] = new TGeoXtru(2);
2135 Double_t* xvert = new Double_t[nedges+2];
2136 Double_t* yvert = new Double_t[nedges+2];
2137 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2138 ////////////////////////////////////////
2139 // Positioning the vertices for TGeoXTru
2140 ////////////////////////////////////////
2141 xvert[0] = 0., yvert[0] = 0.;
2142 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2143 for(Int_t i=0; i< nedges; i++)
2144 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2145 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2146 ////////////////////////////////////////
2147 // Defining TGeoXTru PolyGone
2148 ////////////////////////////////////////
2149 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2150 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2151 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2152 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2153 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2154 TGeoVolume* coolingtubearc[2];
2155 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2156 coolingtubearcshape[0],fSSDCoolingTubeWater);
2157 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2158 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2159 coolingtubearc[0]->SetLineColor(fColorWater);
2160 coolingtubearc[1]->SetLineColor(fColorPhynox);
2161 ////////////////////////////////////////////
2162 // Defining TGeoTubeSeg Part of Cooling Tube
2163 ////////////////////////////////////////////
2164 TGeoTubeSeg* coolingtubesegshape[2];
2165 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2166 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2167 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2168 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2169 TGeoVolume* coolingtubeseg[2];
2170 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2171 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2172 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2173 coolingtubesegshape[1],fSSDCoolingTubeWater);
2174 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2175 coolingtubeseg[1]->SetLineColor(fColorWater);
2176 /////////////////////////////////////////////////////////////
2177 // Virtual Volume containing Cooling Tube Support
2178 /////////////////////////////////////////////////////////////
2179 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2180 const Int_t kvirtualvertexnumber = 8;
2181 TVector3* virtualvertex[kvirtualvertexnumber];
2182 ////////////////////////////////////////
2183 // Positioning the vertices for TGeoXTru
2184 ////////////////////////////////////////
2185 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2186 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2187 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2188 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2189 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2190 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2191 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2192 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2193 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2194 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2195 xmothervertex[i] = virtualvertex[i]->X(),
2196 ymothervertex[i] = virtualvertex[i]->Y();
2197 ////////////////////////////////////////
2198 // Defining TGeoXTru PolyGone
2199 ////////////////////////////////////////
2200 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2201 ymothervertex);
2202 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2203 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
cd2243fb 2204 /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2205 virtualCoolingTubeSupportShape,fSSDAir); */
2206 TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
2207
bf210566 2208 ////////////////////////////////////////
2209 // Positioning Volumes in Virtual Volume
2210 ////////////////////////////////////////
2211 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2212 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2213 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2214 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2215 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
cd2243fb 2216 //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2217 //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2218 //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2219 //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
bf210566 2220 /////////////////////////////////////////////////////////////
2221 // Deallocating memory
2222 /////////////////////////////////////////////////////////////
2223 delete [] vertexposition;
3e008bd7 2224 delete [] xvertexpoints;
2225 delete [] yvertexpoints;
2226 delete [] xvert;
2227 delete [] yvert;
bf210566 2228 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2229 delete virtualvertex[i];
2230 /////////////////////////////////////////////////////////////
2231 return virtualcoolingtubesupport;
2232}
2233/////////////////////////////////////////////////////////////////////////////////
2234TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2235 /////////////////////////////////////////////////////////////
2236 // Method generating List containing SSD Hybrid Components
2237 /////////////////////////////////////////////////////////////
2238 TList* ssdhybridlist = new TList();
2239 const Int_t kssdstiffenernumber = 2;
2240 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2241 - 2.*fgkSSDModuleStiffenerPosition[1]
2242 - fgkSSDStiffenerWidth;
2243 Double_t ssdchipcablesradius[kssdstiffenernumber];
2244 for(Int_t i=0; i<kssdstiffenernumber; i++)
2245 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2246 - fgkSSDChipCablesHeight[0]
2247 - fgkSSDChipCablesHeight[1]);
2248 /////////////////////////////////////////////////////////////
2249 // Mother Volumes Containers
2250 /////////////////////////////////////////////////////////////
2251 const Int_t kmothernumber = 2;
3cf6a656 2252 const Int_t kmothervertexnumber = 8;
bf210566 2253 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2254 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
3cf6a656 2255
2256 TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
2257 TGeoVolume* ssdhybridmother[kmothernumber][2];
2258
2259 TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
2260 TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
2261 TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
2262
bf210566 2263 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2264 for(Int_t i=0; i<kmothernumber; i++){
3cf6a656 2265 xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
2266 ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
2267 xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
2268 ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2269 -fgkSSDChipCablesHeight[i+2];
2270
2271 xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
2272 ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
2273 xmothervertex[i][3] = xmothervertex[i][2];
2274 ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1];
2275
2276 xmothervertex[i][4] = xmothervertex[i][2]-0.4;
2277 ymothervertex[i][4] = ymothervertex[i][3];
2278 xmothervertex[i][5] = xmothervertex[i][4];
2279 ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i];
2280
2281 xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
2282 ymothervertex[i][6] = ymothervertex[i][5];
2283
2284 xmothervertex[i][7] = xmothervertex[i][6];
2285 ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
2286
2287 for (Int_t j = 0; j<8; j++) {
27faa937 2288 // cout << "vtx " << j << " " << xmothervertex[i][j] << " " << ymothervertex[i][j] << endl;
3cf6a656 2289 }
2290 TGeoXtru *shape = new TGeoXtru(2);
2291 shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
2292 shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
2293 shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
2294 ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
2295 ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
2296 ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
bf210566 2297 }
2298 /////////////////////////////////////////////////////////////
2299 // SSD Stiffener
2300 /////////////////////////////////////////////////////////////
2301 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2302 0.5*fgkSSDStiffenerLength,
ca86fdb4 2303 0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
bf210566 2304 0.5*fgkSSDStiffenerHeight);
2305 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2306 fSSDStiffenerMedium);
2307 ssdstiffener->SetLineColor(fColorStiffener);
3cf6a656 2308
bf210566 2309////////////////////////////
2310// Capacitor 0603-2200 nF
2311///////////////////////////
2312 const Int_t knapacitor0603number = 5;
2313 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
3cf6a656 2314 0.5*fgkSSDCapacitor0603Length,
2315 0.5*(fgkSSDCapacitor0603Width),
2316 0.5*fgkSSDCapacitor0603Height);
bf210566 2317 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2318 fSSDStiffener0603CapacitorMedium);
2319 capacitor0603->SetLineColor(fColorAl);
3cf6a656 2320
2321 TGeoVolume* ssdchip = GetSSDChip();
2322
2323 const Int_t knedges = 5;
2324 TGeoVolume *ssdchipcables[2];
2325
bf210566 2326 for(Int_t i=0; i<kmothernumber; i++){
3cf6a656 2327 for(Int_t j=0; j<kssdstiffenernumber; j++){
2328 ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
2329 for(Int_t k=1; k<knapacitor0603number+1; k++){
2330 ssdhybridmother[i][j]->AddNode(capacitor0603,k,
2331 new TGeoCombiTrans("",
2332 -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
2333 -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
2334 (k-3.)/6*fgkSSDStiffenerLength,
2335 hybridmotherrotInv));
2336 }
2337 }
2338
2339 GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
2340 for(Int_t k=0; k<fgkSSDChipNumber; k++){
2341 TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
2342 - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
2343 - fgkSSDChipCablesHeight[i+2],
2344 (k+0.5-fgkSSDChipNumber/2)*
2345 (fgkSSDChipLength + fgkSSDChipSeparationLength));
2346 TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
2347 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
2348 (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
2349 hybridmotherrotInv);
bf210566 2350 for(Int_t j=0; j<kssdstiffenernumber; j++){
3cf6a656 2351 ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
2352 ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
2353 }
2354 }
2355 // Final placement by assembly
2356 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
2357 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
2358 ssdhybridlist->Add(ssdhybridassembly[i]);
bf210566 2359 }
3cf6a656 2360 /////////////////////////////////////////////////////////////
2361 // Mother Volume Containing Capacitor Part
2362 /////////////////////////////////////////////////////////////
bf210566 2363 const Int_t kcapacitormothernumber = 8;
2364 Double_t xcapacitorvertex[kcapacitormothernumber];
2365 Double_t ycapacitorvertex[kcapacitormothernumber];
2366 ///////////////////////
2367 // Setting the vertices
2368 ///////////////////////
2369 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2370 xcapacitorvertex[1] = xcapacitorvertex[0];
2371 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2372 xcapacitorvertex[3] = xcapacitorvertex[2];
2373 xcapacitorvertex[4] = xcapacitorvertex[0];
2374 xcapacitorvertex[5] = xcapacitorvertex[0];
2375 xcapacitorvertex[6] = -xcapacitorvertex[0];
2376 xcapacitorvertex[7] = xcapacitorvertex[6];
2377 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2378 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2379 ycapacitorvertex[2] = ycapacitorvertex[1];
2380 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2381 ycapacitorvertex[4] = ycapacitorvertex[3];
2382 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2383 ycapacitorvertex[6] = ycapacitorvertex[5];
2384 ycapacitorvertex[7] = ycapacitorvertex[0];
2385 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2386 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2387 ycapacitorvertex);
2388 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2389 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
ca86fdb4 2390// TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2391// fSSDAir);
2392 TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
d7599219 2393////////////////////////////
bf210566 2394// Connector
d7599219 2395///////////////////////////
bf210566 2396 const Int_t kssdconnectornumber = 2;
2397 TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2398 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2399 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2400 + fgkSSDConnectorAlHeight};
2401 const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2402 TGeoVolume* ssdconnector[kssdconnectornumber];
2403 for(Int_t i=0; i<kssdconnectornumber; i++){
2404 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2405 0.5*fgkSSDConnectorWidth,
2406 0.5*((1-i)*fgkSSDConnectorAlHeight
2407 + i*fgkSSDConnectorNiHeight),
2408 i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2409 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2410 i==0 ? fSSDAlTraceFlexMedium
2411 : fSSDStiffenerConnectorMedium);
2412 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2413 }
2414 TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2415 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2416 + fgkSSDConnectorPosition[0]
2417 - fgkSSDConnectorSeparation
2418 - 1.5*fgkSSDConnectorLength,
2419 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2420 - fgkSSDConnectorPosition[1]
2421 - ssdconnectorshape[0]->GetDY(),0.0);
2422 ssdconnectortrans[1] = new TGeoTranslation(
2423 - ssdstiffenershape->GetDX()
2424 + fgkSSDConnectorPosition[0]
2425 - 0.5*fgkSSDConnectorLength,
2426 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2427 - fgkSSDConnectorPosition[1]
2428 - ssdconnectorshape[0]->GetDY(),0.0);
2429 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2430 - fgkSSDConnectorPosition[0]
2431 + fgkSSDConnectorSeparation
2432 + 1.5*fgkSSDConnectorLength,
2433 -(ssdstiffenershape->GetDY()
2434 - fgkSSDConnectorPosition[1]
2435 - ssdconnectorshape[0]->GetDY()),0.0);
2436 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2437 - fgkSSDConnectorPosition[0]
2438 + 0.5*fgkSSDConnectorLength,
2439 -(ssdstiffenershape->GetDY()
2440 - fgkSSDConnectorPosition[1]
2441 - ssdconnectorshape[0]->GetDY()),0.0);
2442 for(Int_t i=0; i<2*kssdconnectornumber; i++)
2443 for(Int_t j=0; j<kssdconnectornumber; j++)
2444 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2445////////////////////////////
2446// Capacitor 1812-330 nF
2447///////////////////////////
2448 Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2449 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2450 0.5*fgkSSDCapacitor1812Length,
2451 0.5*fgkSSDCapacitor1812Width,
bf210566 2452 0.5*fgkSSDCapacitor1812Height,
2453 ssdcapacitor1812origin);
44285dfa 2454 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2455 fSSDStiffener1812CapacitorMedium);
2456 capacitor1812->SetLineColor(fColorAl);
bf210566 2457 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2458 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2459 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2460 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
d7599219 2461////////////////////////////
2462//Hybrid Wire
2463////////////////////////////
44285dfa 2464 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2465 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2466 - fgkSSDConnectorSeparation;
44285dfa 2467 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2468 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
60e55aee 2469 Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2470
44285dfa 2471 Double_t wireangle = TMath::ATan(wirex/wirey);
2472 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2473 fgkSSDWireRadius, 0.5*ssdwireradius);
2474 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2475 fSSDStiffenerHybridWireMedium);
2476 hybridwire->SetLineColor(fColorPhynox);
2477 TGeoCombiTrans* hybridwirecombitrans[2];
2478 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2479 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2480 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2481 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2482 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2483 ssdstiffenershape->GetDZ()
2484 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
d7599219 2485 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2486 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2487 0.0,
2488 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2489 0.0,
2490 new TGeoRotation("HybridWireRot2",
2491 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2492 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2493 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2494 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2495 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2496 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2497 /////////////////////////////////////////////////////////////
bf210566 2498 // Deallocating memory
44285dfa 2499 /////////////////////////////////////////////////////////////
bf210566 2500 delete hybridwirecombitrans[0];
2501 delete hybridwirecombitrans[1];
bf210566 2502 return ssdhybridlist;
2503 /////////////////////////////////////////////////////////////
2504}
2505///////////////////////////////////////////////////////////////////////////////
2506TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2507 /////////////////////////////////////////////////////////////
2508 // SSD Cooling Block System
2509 /////////////////////////////////////////////////////////////
2510 // SSD Cooling Block and Cooling Tube Transformations
2511 /////////////////////////////////////////////////////////////
2512 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2513 localcoolingblockrot->SetAngles(0.,90.,0.);
535e8862 2514 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
bf210566 2515 TVector3* coolingblocktransvector;
2516 coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2517 + fgkSSDCoolingBlockLength,
2518 fgkSSDSensorLength
2519 - 2.*fgkSSDModuleStiffenerPosition[1]
2520 - fgkSSDCoolingBlockWidth);
2521 const Int_t kcoolingblocktransnumber = 2;
2522 const Int_t kcoolingblocknumber = 4;
2523 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2524 TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2525 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2526 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2527 TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2528 localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
535e8862 2529 0.5*fgkSSDCoolingBlockWidth,
2530 fgkSSDCoolingBlockHoleCenter);
2531 TGeoCombiTrans localcoolingtubematrix (*localcoolingtubetrans,*localcoolingtuberot);
bf210566 2532 Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2533 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
535e8862 2534 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2535 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X()+2*coolingtubedistance,
2536 j*coolingblocktransvector->Y(),
2537 - 0.5*(fgkSSDCoolingBlockHoleCenter
2538 + fgkCoolingTubeRmax));
2539 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
2540 coolingtubematrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingtubematrix);
2541 }
d7599219 2542 }
bf210566 2543 /////////////////////////////////////////////////////////////
2544 // Virtual Volume containing CoolingBlock System
2545 /////////////////////////////////////////////////////////////
2546 TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2547 const Int_t kmothervertexnumber = 16;
2548 Double_t xmothervertex[kmothervertexnumber];
2549 Double_t ymothervertex[kmothervertexnumber];
2550 ///////////////////////
2551 // Setting the vertices
2552 ///////////////////////fgkCoolingTubeSupportRmax
2553 xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2554 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2555 + fgkSSDCoolingBlockWidth;
2556 xmothervertex[2] = coolingblocktransvector->X()
2557 + fgkSSDCoolingBlockLength
2558 + 4*coolingtubedistance;
2559 ymothervertex[2] = ymothervertex[1];
2560 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2561 xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2562 ymothervertex[4] = ymothervertex[0];
2563 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2564 xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2565 ymothervertex[6] = ymothervertex[5];
2566 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2567 - fgkSSDCoolingBlockWidth;
2568 xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2569 xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2570 - coolingtubedistance;
2571 xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2572 ymothervertex[10] = ymothervertex[9];
2573 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2574 xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2575 xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2576 xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2577 ymothervertex[14] = ymothervertex[13];
2578 xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2579 //////////////////////////////////////////////////////////
2580 coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2581 xmothervertex,ymothervertex);
2582 coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2583 + fgkCoolingTubeRmax));
2584 coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2585 + fgkCoolingTubeRmax));
ca86fdb4 2586 TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
bf210566 2587 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2588 /////////////////////////////////////////////////////////////
2589 // Adding Cooling block to mother volume
2590 /////////////////////////////////////////////////////////////
3cf6a656 2591 for(Int_t i=0; i<kcoolingblocknumber; i++){
2592 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
d7599219 2593 }
bf210566 2594 /////////////////////////////////////////////////////////////
2595 // Deallocating memory
2596 /////////////////////////////////////////////////////////////
3cf6a656 2597 delete coolingblocktransvector;
2598 delete localcoolingblockrot;
2599
2600 return coolingsystemother;
d7599219 2601}
2602/////////////////////////////////////////////////////////////////////////////////
bf210566 2603TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2604 /////////////////////////////////////////////////////////////
bf210566 2605 // SSD Flex
44285dfa 2606 /////////////////////////////////////////////////////////////
bf210566 2607 const Int_t kssdflexlayernumber = 2;
2608 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2609 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2610 const Int_t kmothervertexnumber = 17;
2611 Double_t xmothervertex[kmothervertexnumber];
2612 Double_t ymothervertex[kmothervertexnumber];
2613 /////////////////////////////////////////////
2614 // Auxiliary variables for vertex positioning
2615 /////////////////////////////////////////////
2616 const Int_t kssdflexboxnumber = 5;
44285dfa 2617 Double_t ssdflexboxlength[kssdflexboxnumber];
2618 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2619 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2620 * fgkSSDChipSeparationLength
2621 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2622 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2623 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2624 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2625 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2626 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2627 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2628 - ssdflexboxlength[1];
44285dfa 2629 Double_t ssdflexboxwidth[kssdflexboxnumber];
2630 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2631 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2632 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2633 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2634 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2635 ///////////////////////
2636 // Setting the vertices
2637 ///////////////////////
2638 xmothervertex[0] = 0.0;
2639 xmothervertex[1] = xmothervertex[0];
2640 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2641 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2642 + ssdflexboxlength[4];
2643 xmothervertex[4] = xmothervertex[3];
2644 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2645 xmothervertex[6] = xmothervertex[5];
2646 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2647 xmothervertex[8] = xmothervertex[7];
2648 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2649 xmothervertex[10] = xmothervertex[9];
2650 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2651 xmothervertex[12] = xmothervertex[11];
2652 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2653 xmothervertex[14] = xmothervertex[13];
2654 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2655 xmothervertex[16] = xmothervertex[15];
2656 ymothervertex[0] = 0.0;
2657 ymothervertex[1] = fgkSSDFlexWidth[1];
2658 ymothervertex[2] = fgkSSDFlexWidth[0];
2659 ymothervertex[3] = ymothervertex[2];
2660 ymothervertex[4] = ymothervertex[0];
2661 ymothervertex[5] = ymothervertex[4];
2662 ymothervertex[6] = ssdflexboxwidth[2];
2663 ymothervertex[7] = ymothervertex[6];
2664 ymothervertex[8] = ymothervertex[0];
2665 ymothervertex[9] = ymothervertex[8];
2666 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2667 ymothervertex[11] = ymothervertex[10];
2668 ymothervertex[12] = ymothervertex[0];
2669 ymothervertex[13] = ymothervertex[12];
2670 ymothervertex[14] = ymothervertex[7];
2671 ymothervertex[15] = ymothervertex[14];
2672 ymothervertex[16] = ymothervertex[0];
2673 /////////////////////////////////////////////////////////////
2674 // First Mother Volume containing SSDFlex
2675 /////////////////////////////////////////////////////////////
2676 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2677 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2678 ymothervertex);
2679 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2680 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
ca86fdb4 2681 TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2682// TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2683// fSSDAir);
bf210566 2684 /////////////////////////////////////////////////////////////
2685 // SSDFlex Layer Shapes
2686 /////////////////////////////////////////////////////////////
2687 for(Int_t i=0; i<kssdflexlayernumber; i++){
2688 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2689 ymothervertex);
2690 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2691 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2692 }
2693 /////////////////////////////////////
2694 // Setting Layers into Mother Volume
2695 /////////////////////////////////////
2696 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2697 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2698 fSSDKaptonFlexMedium};
2699 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2700 "AlFlexLay2","KaptonFlexLay2"};
2701 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2702 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2703 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2704 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2705 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2706 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2707 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2708 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2709 + fgkSSDFlexHeight[1]));
2710 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2711 }
bf210566 2712 return ssdflexmother;
d7599219 2713}
2714/////////////////////////////////////////////////////////////////////////////////
bf210566 2715TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2716 /////////////////////////////////////////////////////////////
2717 // Method generating SSD End Flex
d7599219 2718 /////////////////////////////////////////
bf210566 2719 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2720 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2721 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2722 * TMath::DegToRad()*ssdflexradiusmax
2723 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 2724 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2725 - 0.1*fgkSSDFlexFullLength;
bf210566 2726 const Int_t knedges = 20;
2727 const Int_t karcnumber = 2;
2728 TVector3* vertexposition[karcnumber*(knedges+1)];
2729 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2730 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2731 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2732 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2733 - 90.0*TMath::DegToRad()};
2734 TVector3* referencetrans[karcnumber];
2735 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2736 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2737 radius[0]);
2738 referencetrans[1] = new TVector3(referencetrans[0]->X()
2739 + fgkSSDFlexLength[2],
2740 - fgkSSDStiffenerHeight);
2741for(Int_t i=0; i<karcnumber; i++){
2742 for(Int_t j=0; j<knedges+1; j++){
2743 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2744 radius[i]*SinD(angle[i]));
2745 angle[i] += deltangle[i]*(1.0-2.0*i);
2746 }
2747 }
2748 ///////////////////////
2749 // Setting the vertices
2750 ///////////////////////
2751 const Int_t kendflexlayernumber = 4;
2752 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2753 TVector3** vertex[kendflexlayernumber];
2754 for(Int_t i=0; i<kendflexlayernumber; i++)
2755 vertex[i] = new TVector3*[kendflexvertexnumber];
2756 TVector3* transvector[kendflexlayernumber+1];
2757 TVector3* deltatransvector = new TVector3();
2758 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2759 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2760 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2761 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2762 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2763 * CosD(fgkSSDFlexAngle),
2764 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2765 * SinD(fgkSSDFlexAngle),0.0);
2766 *transvector[i] = *transvector[i-1]+*deltatransvector;
2767 }
2768 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2769 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2770 for(Int_t i=0; i<karcnumber; i++){
2771 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2772 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2773 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2774 /radius[i];
2775 }
2776 }
2777 for(Int_t i=0; i<kendflexlayernumber; i++){
2778 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2779 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2780 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2781 if(j<(knedges+1)){
2782 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2783 vertexposition[j]->Y()*ratioradius[0][i+1]);
2784 vertex[i][j+2]->RotateZ(referenceangle[0]);
2785 *vertex[i][j+2] += *referencetrans[0];
2786 vertex[i][4*(knedges+1)-j+1] =
2787 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2788 vertexposition[j]->Y()*ratioradius[0][i]);
2789 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2790 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2791 }
2792 else{
2793
2794 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2795 vertexposition[j]->Y()*ratioradius[1][i+1]);
2796 vertex[i][j+2]->RotateZ(referenceangle[1]);
2797 *vertex[i][j+2] += *referencetrans[1];
2798 vertex[i][4*(knedges+1)-j+1] =
2799 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2800 vertexposition[j]->Y()*ratioradius[1][i]);
2801 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2802 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2803 }
2804 }
2805 }
44285dfa 2806 /////////////////////////////////////////////////////////////
bf210566 2807 // First Mother Volume containing SSDEndFlex
2808 /////////////////////////////////////////////////////////////
2809 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2810 Double_t xmothervertex[kendflexvertexnumber];
2811 Double_t ymothervertex[kendflexvertexnumber];
2812 xmothervertex[0] = vertex[0][0]->X();
2813 ymothervertex[0] = vertex[0][0]->Y();
2814 for(Int_t i=1; i<kendflexvertexnumber; i++){
2815 if(i<2*(knedges+1)+2){
2816 xmothervertex[i] = vertex[3][i]->X();
2817 ymothervertex[i] = vertex[3][i]->Y();
2818 }
2819 else{
2820 xmothervertex[i] = vertex[0][i]->X();
2821 ymothervertex[i] = vertex[0][i]->Y();
2822 }
2823 }
2824 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2825 xmothervertex,ymothervertex);
2826 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2827 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
0fb26117 2828// TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2829// ssdendflexmothershape,fSSDAir);
2830 TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
bf210566 2831 //////////////////////////////////////
2832 // End Flex TGeoXtru Layer Definition
2833 //////////////////////////////////////
2834 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2835 TGeoVolume* ssdendflex[kendflexlayernumber];
2836 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2837 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2838 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2839 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2840 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2841 fSSDKaptonFlexMedium};
2842 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2843 "AlEndFlexLay2","KaptonEndFlexLay2"};
2844 for(Int_t i=0; i<kendflexlayernumber; i++){
2845 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2846 xvertex[i][j] = vertex[i][j]->X();
2847 yvertex[i][j] = vertex[i][j]->Y();
2848 }
2849 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2850 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2851 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2852 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2853 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2854 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2855 ssdendflexmother->AddNode(ssdendflex[i],1);
2856 }
44285dfa 2857 /////////////////////////////////////////////////////////////
bf210566 2858 // Deallocating memory
44285dfa 2859 /////////////////////////////////////////////////////////////
bf210566 2860 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2861 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2862 for(Int_t i=0; i<kendflexlayernumber; i++){
2863 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2864 delete [] vertex[i];
2865 }
2866 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2867 delete deltatransvector;
44285dfa 2868 /////////////////////////////////////////////////////////////
6727e2db 2869 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 2870 return ssdendflexmother;
d7599219 2871}
9b0c60ab 2872///////////////////////////////////////////////////////////////////////////////
bf210566 2873TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 2874 /////////////////////////////////////////////////////////////
9b0c60ab 2875 // Method generating the Mounting Block
bf210566 2876 /////////////////////////////////////////////////////////////
9b0c60ab 2877 const Int_t kvertexnumber = 8;
2878 Double_t xvertex[kvertexnumber];
2879 Double_t yvertex[kvertexnumber];
2880 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2881 xvertex[1] = xvertex[0];
2882 xvertex[2] = -xvertex[0];
2883 xvertex[3] = xvertex[2];
2884 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2885 - fgkSSDMountingBlockLength[2]);
2886 xvertex[5] = xvertex[4];
2887 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2888 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2889 - fgkSSDMountingBlockScrewHoleRadius[0];
2890 xvertex[7] = xvertex[6];
2891 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 2892 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 2893 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2894 yvertex[2] = yvertex[1];
2895 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2896 yvertex[4] = yvertex[3];
2897 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2898 - fgkSSDMountingBlockHeight[0];
2899 yvertex[6] = yvertex[5];
2900 yvertex[7] = yvertex[0];
160835d5 2901
9b0c60ab 2902 ///////////////////////////////////////////////////////////////////////
2903 // TGeoXTru Volume definition for Mounting Block Part
2904 ///////////////////////////////////////////////////////////////////////
2905 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2906 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2907 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2908 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 2909 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 2910 ssdmountingblockshape,
2911 fSSDMountingBlockMedium);
2912 ssdmountingblock->SetLineColor(fColorG10);
2913 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2914 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2915 TGeoRotation* mountingblockrot = new TGeoRotation();
2916 mountingblockrot->SetAngles(90.,180.,-90.);
2917 mountingblockcombitrans->SetRotation(*mountingblockrot);
2918 /////////////////////////////////////////////////////////////
2919 // Generating the Mounting Block Screw Vertices
2920 /////////////////////////////////////////////////////////////
2921 const Int_t kscrewvertexnumber = 15;
2922 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
2923 - fgkSSDMountingBlockScrewHoleEdge)
2924 / fgkSSDMountingBlockScrewHoleRadius[0])
2925 * TMath::RadToDeg();
2926 Double_t phi0 = 90.+alpha;
2927 Double_t phi = 270.-2*alpha;
2928 Double_t deltaphi = phi/kscrewvertexnumber;
2929 TVector3* screwvertex[kscrewvertexnumber+1];
2930 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
2931 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
2932 *CosD(phi0+i*deltaphi),
2933 fgkSSDMountingBlockScrewHoleRadius[0]
2934 *SinD(phi0+i*deltaphi));
2935 Double_t xscrewvertex[kscrewvertexnumber+6];
2936 Double_t yscrewvertex[kscrewvertexnumber+6];
2937 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
2938 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
2939 - fgkSSDMountingBlockScrewHoleEdge);
2940 xscrewvertex[1] = xscrewvertex[0];
2941 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2942 xscrewvertex[2] = screwvertex[0]->X();
2943 yscrewvertex[2] = yscrewvertex[1];
2944 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
2945 xscrewvertex[i+3] = screwvertex[i]->X();
2946 yscrewvertex[i+3] = screwvertex[i]->Y();
2947 }
2948 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2949 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
2950 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
2951 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
2952 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
2953 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
2954 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
2955 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
2956 + fgkSSDMountingBlockHeight[2]);
2957 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
2958 ssdmountingblockscrewshape,
2959 fSSDMountingBlockMedium);
2960 ssdmountingblockscrew->SetLineColor(fColorG10);
2961 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
2962 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
2963 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2964 - yscrewvertex[1],
2965 0.5*fgkSSDMountingBlockHeight[0]
2966 - fgkSSDMountingBlockHeight[2]
2967 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2968 + fgkSSDMountingBlockHeight[2]
2969 - yvertex[0]));
2970 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2971 -0.5*fgkSSDMountingBlockScrewHoleEdge,
2972 yscrewvertex[1]
2973 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2974 +fgkSSDMountingBlockHeight[2]
2975 -yvertex[0]));
2976 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2977 yscrewvertex[1],
2978 - 0.5*fgkSSDMountingBlockHeight[0]
2979 + fgkSSDMountingBlockHeight[2]
2980 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2981 + fgkSSDMountingBlockHeight[2]
2982 - yvertex[0]));
2983 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2984 yscrewvertex[1],
2985 - yscrewvertex[1]
2986 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2987 + fgkSSDMountingBlockHeight[2]
2988 - yvertex[0]));
2989 TGeoRotation* ssdmountingblockscrewrot[4];
2990 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
2991 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
2992 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
2993 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
2994 for(Int_t i=1; i<4; i++)
2995 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
2996 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
2997 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
2998 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
2999 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3000 + xvertex[0],yscrewvertex[1]
3001 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3002 + fgkSSDMountingBlockHeight[2]
3003 - yvertex[0]),0.);
3004 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3005 for(Int_t i=0; i<4; i++){
3006 ssdmountingblockscrewmatrix[i] =
3007 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3008 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3009 }
3010 ///////////////////////////////////////////////////////////////////////
3011 // TGeoXtru for Mother Volume
3012 ///////////////////////////////////////////////////////////////////////
3013 const Int_t kvertexmothernumber = 12;
3014 Double_t xmothervertex[kvertexmothernumber];
3015 Double_t ymothervertex[kvertexmothernumber];
3016 for(Int_t i=0; i<6; i++){
3017 xmothervertex[i] = xvertex[i];
3018 ymothervertex[i] = yvertex[i];
3019 }
3020 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3021 ymothervertex[6] = ymothervertex[5];
3022 xmothervertex[7] = xmothervertex[6];
3023 ymothervertex[7] = ymothervertex[4];
3024 xmothervertex[8] = xmothervertex[7]
3025 + 0.5*(fgkSSDMountingBlockLength[1]
3026 - fgkSSDMountingBlockLength[2]);
3027 ymothervertex[8] = ymothervertex[4];
3028 xmothervertex[9] = xmothervertex[8];
3029 ymothervertex[9] = ymothervertex[2];
3030 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3031 ymothervertex[10] = ymothervertex[1];
3032 xmothervertex[11] = xmothervertex[10];
3033 ymothervertex[11] = ymothervertex[0];
3034 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3035 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3036 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3037 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3038 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3039 ssdmountingblockmothershape,
3040 fSSDAir);
3041 /////////////////////////////////////////////////////////////
3042 // Placing the Volumes into Mother Volume
3043 /////////////////////////////////////////////////////////////
3044 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3045 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3046 for(Int_t i=0; i<4; i++)
3047 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3048 ssdmountingblockscrewmatrix[i]);
3049 /////////////////////////////////////////////////////////////
3050 // Deallocating memory
3051 /////////////////////////////////////////////////////////////
3052 delete mountingblockrot;
3053 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3054 delete ssdmountingblockglobalrot;
3055 delete ssdmountingblockglobaltrans;
3056 /////////////////////////////////////////////////////////////
3057 return ssdmountingblockmother;
3058}
3059///////////////////////////////////////////////////////////////////////////////
3060 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3061 /////////////////////////////////////////////////////////////
3062 // Method generating the Mounting Block Clip
3063 /////////////////////////////////////////////////////////////
3064 const Int_t kmothervertexnumber = 10;
3065 Double_t xmothervertex[kmothervertexnumber];
3066 Double_t ymothervertex[kmothervertexnumber];
3067 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3068 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3069 xmothervertex[1] = xmothervertex[0];
3070 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3071 - fgkMountingBlockClibScrewRadius);
3072 xmothervertex[3] = xmothervertex[2];
3073 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3074 xmothervertex[5] = xmothervertex[4];
3075 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3076 xmothervertex[7] = xmothervertex[6];
3077 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3078 xmothervertex[9] = xmothervertex[8];
3079 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 3080 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 3081 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3082 ymothervertex[2] = ymothervertex[1];
3083 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3084 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3085 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3086 ymothervertex[4] = ymothervertex[3];
3087 ymothervertex[5] = ymothervertex[2];
3088 ymothervertex[6] = ymothervertex[5];
3089 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3090 ymothervertex[8] = ymothervertex[7];
3091 ymothervertex[9] = ymothervertex[0];
160835d5 3092
9b0c60ab 3093 ///////////////////////////////////////////////////////////////////////
3094 // TGeoXTru Volume definition for Mounting Block Clip Part
3095 ///////////////////////////////////////////////////////////////////////
3096 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3097 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3098 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3099 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3100 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3101 ssdmountingblockclipshape,fSSDAir);
3102 ssdmountingblockclip->SetLineColor(4);
3103 ///////////////////////////////////////////////////////////////////////
3104 // TGeoXTru Volume definition for Clip
3105 ///////////////////////////////////////////////////////////////////////
3106 const Int_t kclipvertexnumber = 6;
3107 Double_t xclipvertex[kclipvertexnumber];
3108 Double_t yclipvertex[kclipvertexnumber];
3109 xclipvertex[0] = xmothervertex[0];
3110 xclipvertex[1] = xclipvertex[0];
3111 xclipvertex[2] = xmothervertex[6];
3112 xclipvertex[3] = xclipvertex[2];
3113 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3114 xclipvertex[5] = xclipvertex[4];
3115 yclipvertex[0] = ymothervertex[0];
3116 yclipvertex[1] = ymothervertex[1];
3117 yclipvertex[2] = yclipvertex[1];
3118 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3119 yclipvertex[4] = yclipvertex[3];
3120 yclipvertex[5] = yclipvertex[0];
3121 TGeoXtru* clipshape = new TGeoXtru(2);
3122 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3123 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3124 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3125 + fgkMountingBlockClibWidth);
3126 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3127 clip->SetLineColor(18);
3128 ///////////////////////////////////////////////////////////////////////
3129 // Ladder Support Piece
3130 ///////////////////////////////////////////////////////////////////////
3131 const Int_t ksupportvertexnumber = 4;
3132 Double_t xsupportvertex[ksupportvertexnumber];
3133 Double_t ysupportvertex[ksupportvertexnumber];
3134 xsupportvertex[0] = xclipvertex[5];
3135 xsupportvertex[1] = xsupportvertex[0];
3136 xsupportvertex[2] = xmothervertex[9];
3137 xsupportvertex[3] = xsupportvertex[2];
3138 ysupportvertex[0] = yclipvertex[0];
3139 ysupportvertex[1] = yclipvertex[3];
3140 ysupportvertex[2] = ysupportvertex[1];
3141 ysupportvertex[3] = ysupportvertex[0];
3142 TGeoXtru* supportshape = new TGeoXtru(2);
3143 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3144 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3145 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3146 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3147 support->SetLineColor(9);
3148 ///////////////////////////////////////////////////////////////////////
3149 // TGeoXTru Volume definition for Screw
3150 ///////////////////////////////////////////////////////////////////////
3151 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3152 0.5*fgkMountingBlockClibScrewRadius};
3153 Int_t edgesnumber[2] = {50,6};
3154 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3155 +0.5*(ymothervertex[3]-ymothervertex[2])};
851c0ce3 3156 TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
9b0c60ab 3157 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3158 clipscrew->SetLineColor(12);
3159 TGeoRotation* screwrot = new TGeoRotation();
3160 screwrot->SetAngles(0.,90.,0.);
3161 TGeoTranslation* screwtrans = new TGeoTranslation();
3162 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3163 0.5*(ymothervertex[3]+ymothervertex[2]),
3164 0.5*fgkSSDMountingBlockWidth+
3165 -0.5*fgkMountingBlockSupportWidth[0]);
3166 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3167 ///////////////////////////////////////////////////////////////////////
3168 // Placing the Volumes
3169 ///////////////////////////////////////////////////////////////////////
3170 ssdmountingblockclip->AddNode(clip,1);
3171 ssdmountingblockclip->AddNode(support,1);
3172 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3173 /////////////////////////////////////////////////////////////
3174 // Deallocating memory
3175 /////////////////////////////////////////////////////////////
3176 delete screwtrans;
3177 delete screwrot;
3178 /////////////////////////////////////////////////////////////
3179 return ssdmountingblockclip;
d7599219 3180}
bf210566 3181///////////////////////////////////////////////////////////////////////////////
cd2243fb 3182void AliITSv11GeometrySSD::CreateCoolingTubes() {
44285dfa 3183 /////////////////////////////////////////////////////////////
bf210566 3184 // Method generating the Cooling Tube
cd2243fb 3185 // sets fcoolingtube and returns list for endladdercoolingtube
44285dfa 3186 /////////////////////////////////////////////////////////////
cd2243fb 3187 TGeoTube *coolingtubeshape[2];
3188 // Ladder Cooling Tubes
3189
3190 // MvL: Simplified cooling tubes
3191 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
3192 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
3193
3194 // End Ladder Cooling Tubes
3195 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3196 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3197 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3198
3199 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
3200 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3201 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
3202 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3203 endladdercoolingtubeshape[0][0]->GetDz());
3204 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3205 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
3206 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3207 endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
3208 // Ladder Cooling Tubes
3209 TGeoVolume* coolingtube[2];
3210 coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
3211 coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
3212 coolingtube[0]->SetLineColor(fColorPhynox);
3213 coolingtube[1]->SetLineColor(fColorWater);
3214
3215 // End Ladder Cooling Tubes
3216 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3217 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3218 endladdercoolingtube[i] = new TGeoVolume*[2];
3219 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3220 endladdercoolingtubeshape[0][0],
3221 fSSDCoolingTubePhynox);
3222 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3223 endladdercoolingtubeshape[0][1],
3224 fSSDCoolingTubeWater);
3225 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3226 endladdercoolingtubeshape[1][0],
3227 fSSDCoolingTubePhynox);
3228 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3229 endladdercoolingtubeshape[1][1],
3230 fSSDCoolingTubeWater);
3231 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3232 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3233 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3234 }
0fb26117 3235
bf210566 3236 /////////////////////////////////////////////////////////////
3237 // Virtual Volume containing Cooling Tubes
3238 /////////////////////////////////////////////////////////////
9b0c60ab 3239 // Ladder Cooling Tubes
cd2243fb 3240 TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
3241 coolingtubeshape[0]->GetRmax(),
3242 coolingtubeshape[0]->GetDz());
3243 fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
3244 fcoolingtube->AddNode(coolingtube[0],1);
3245 fcoolingtube->AddNode(coolingtube[1],1);
3246
9b0c60ab 3247 // End Ladder Cooling Tubes
3248 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3249 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
cd2243fb 3250 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3251 endladdercoolingtubeshape[i][0]->GetRmax(),
3252 endladdercoolingtubeshape[i][0]->GetDz());
3253 fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3254 endladdervirtualcoolingtubeshape[0],
3255 fSSDAir);
3256 fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3257 endladdervirtualcoolingtubeshape[1],
3258 fSSDAir);
3259 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3260 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3261 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3262 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
d7599219 3263}
bf210566 3264///////////////////////////////////////////////////////////////////////////////
3265TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3266 /////////////////////////////////////////////////////////////
bf210566 3267 // Method generating SSD Cooling Block
44285dfa 3268 /////////////////////////////////////////////////////////////
bf210566 3269 const Int_t kvertexnumber = 8;
3270 ///////////////////////////////////////
3271 // Vertex Positioning for TGeoXTru
3272 ///////////////////////////////////////
3273 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3274 vertexposition[0] = new TVector3(0.0,0.0);
3275 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3276 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3277 vertexposition[1]->Y());
3278 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3279 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3280 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3281 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3282 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3283 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3284 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3285 - fgkSSDCoolingBlockHoleLength[0]
3286 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3287 fgkSSDCoolingBlockHeight[0]
3288 - fgkSSDCoolingBlockHoleRadius[1],
3289 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3290 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3291 - fgkSSDCoolingBlockHoleLength[0]),
3292 vertexposition[6]->Y());
3293 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3294 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3295 Double_t phi = 180.-alpha;
3296 Double_t psi = 180.+2.*alpha;
3297 Double_t deltapsi = psi/nedges;
3298 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3299 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3300 fgkSSDCoolingBlockHoleCenter);
3301 for(Int_t i=0; i<nedges+1; i++){
3302 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3303 radius*SinD(phi+i*deltapsi));
3304 *vertexposition[kvertexnumber+i] += (*transvector);
3305 }
3306 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3307 for(Int_t i=0; i<kvertexnumber; i++)
3308 vertexposition[kvertexnumber+nedges+1+i] =
3309 GetReflection(vertexposition[kvertexnumber-1-i],param);
3310 ///////////////////////////////////////////////////////////////////////
3311 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3312 ///////////////////////////////////////////////////////////////////////
3313 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3314 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3315 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3316 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3317 xvertexpoints[i] = vertexposition[i]->X();
3318 yvertexpoints[i] = vertexposition[i]->Y();
3319 }
3320 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3321 yvertexpoints);
3322 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3323 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3324 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3325 ssdcoolingblockshape,
3326 fSSDAlCoolBlockMedium);
3327 ssdcoolingblock->SetLineColor(fColorAl);
3328 /////////////////////////////////////////////////////////////
3329 // Deallocating memory
3330 /////////////////////////////////////////////////////////////
3331 delete [] vertexposition;
7b208ef4 3332 delete [] xvertexpoints;
3333 delete [] yvertexpoints;
bf210566 3334 /////////////////////////////////////////////////////////////
3335 return ssdcoolingblock;
3336}
3337/////////////////////////////////////////////////////////////////////////////////
3cf6a656 3338void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
d7599219 3339 ///////////////////////////////////////////////////////
cd2243fb 3340 static const Int_t kssdchipcablesnumber = 2; // Number of cables: left and right
3341 static const Int_t kssdchipcableslaynumber = 2; // Number of layers: Al and Kapton
3342 static const Int_t kvertexnumber = 4*(nedges+1)+4;
bf210566 3343 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3344 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
cd2243fb 3345 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
bf210566 3346 - fgkSSDChipCablesHeight[0]
3347 - fgkSSDChipCablesHeight[1]);
3348 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3349 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3350 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3351 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3352 - ssdchipcablesradius[0]
3353 - fgkSSDChipCablesWidth[1]
3354 - fgkSSDChipCablesWidth[2]);
3355 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3356 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3357 + fgkSSDChipCablesHeight[1]
3358 + fgkSSDSensorHeight);
d7599219 3359 ///////////////////////////////////////////////////////
bf210566 3360 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3361 ///////////////////////////////////////////////////////
3362 TVector3** vertexposition[kssdchipcableslaynumber];
3363 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3364 new TVector3*[4*(nedges+1)+4];
3365 Double_t ratio[4];
3366 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3367 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3368 / ssdchipcablesradius[0];
3369 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3370 / ssdchipcablesradius[0];
3371 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3372 + fgkSSDChipCablesHeight[1])
3373 / ssdchipcablesradius[0];
3374 Double_t phi = 180.;
3375 Double_t deltaphi = 180./nedges;
3376 Double_t angle = 0.0;
3377 Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3378 Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3379 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3380 xvertexpoints[i] = new Double_t[kvertexnumber];
3381 yvertexpoints[i] = new Double_t[kvertexnumber];
3382 }
3383 TVector3* vertex = new TVector3();
3384 TVector3* transvector[kssdchipcableslaynumber];
3385 transvector[0] = new TVector3(fgkSSDChipWidth,
cd2243fb 3386 SSDChipCablesHeight-ssdchipcablesradius[0]);
bf210566 3387 transvector[1] = new TVector3();
cd2243fb 3388 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
3389 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
3390 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
bf210566 3391 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3392 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3393 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3394 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3395 transvector[1]->SetY(ssdchipcablesradius[0]
3396 + fgkSSDChipCablesHeight[0]
3397 + fgkSSDChipCablesHeight[1]);
3398 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
cd2243fb 3399 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
bf210566 3400 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
cd2243fb 3401 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
bf210566 3402 - i*fgkSSDChipCablesHeight[0]);
3403 vertexposition[i][2*(nedges+1)+2] =
3404 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3405 + fgkSSDChipCablesWidth[1]
3406 + fgkSSDChipCablesWidth[2],
3407 ((1.-i)*fgkSSDChipCablesHeight[i]
3408 + fgkSSDChipCablesHeight[1]));
3409 vertexposition[i][2*(nedges+1)+3] =
3410 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3411 vertexposition[i][2*(nedges+1)+2]->Y()
3412 - fgkSSDChipCablesHeight[i]);
3413 for(Int_t j=0; j<nedges+1; j++){
3414 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3415 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3416 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3417 vertexposition[0][(nedges+1)*i+j+2] =
3418 new TVector3(*vertex+*transvector[i]);
3419 vertexposition[1][(nedges+1)*i+j+2] =
3420 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3421 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3422 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3423 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3424 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3425 new TVector3(vertex->X()*ratio[2*i+1]
3426 + transvector[i]->X(),
3427 vertex->Y()*ratio[2*i+1]
3428 + transvector[i]->Y());
3429 }
3430 }
3431 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3432 for(Int_t j=0; j<kvertexnumber; j++){
3433 xvertexpoints[i][j] = vertexposition[i][j]->X();
3434 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3435 }
3436 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3437 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3438 xvertexpoints[i],yvertexpoints[i]);
3439 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3440 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3441 ssdchipcable[kssdchipcablesnumber*k+i] =
3442 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3443 ssdchipcableshape[kssdchipcablesnumber*k+i],
3444 (kssdchipcablesnumber*k+i)%2==0?
3445 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3446 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3447 }
3448 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3449 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3450 }
44285dfa 3451 /////////////////////////////////////////////////////////////
bf210566 3452 // Mother Volume definition
3453 /////////////////////////////////////////////////////////////
cd2243fb 3454 static const Int_t kmothervertexnumber = 8;
3455 Double_t xmothervertex[kmothervertexnumber];
3456 Double_t ymothervertex[kmothervertexnumber];
3457 xmothervertex[0] = xvertexpoints[0][1];
3458 ymothervertex[0] = yvertexpoints[0][1];
3459 xmothervertex[1] = xvertexpoints[0][2+nedges/2];
3460 ymothervertex[1] = yvertexpoints[0][1];
3461 xmothervertex[2] = xvertexpoints[0][2+nedges/2];
3462 ymothervertex[2] = yvertexpoints[0][2+nedges];
3463 xmothervertex[3] = xvertexpoints[0][3+nedges];
3464 ymothervertex[3] = yvertexpoints[0][3+nedges];
3465 xmothervertex[4] = xvertexpoints[0][3+2*nedges];
3466 ymothervertex[4] = yvertexpoints[0][3+2*nedges];
3467 xmothervertex[5] = xvertexpoints[0][4+2*nedges];
3468 ymothervertex[5] = yvertexpoints[0][4+2*nedges];
3469 xmothervertex[6] = xvertexpoints[1][5+2*nedges];
3470 ymothervertex[6] = yvertexpoints[1][5+2*nedges];
3471 xmothervertex[7] = xvertexpoints[0][1];
3472 ymothervertex[7] = yvertexpoints[1][5+2*nedges];
3473 TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
3474 ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3475 ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3476 ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3477
3cf6a656 3478 cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
3479 cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
cd2243fb 3480
3cf6a656 3481 cableL->AddNode(ssdchipcable[0],1);
3482 cableL->AddNode(ssdchipcable[1],1);
3483 cableR->AddNode(ssdchipcable[2],1);
3484 cableR->AddNode(ssdchipcable[3],1);
cd2243fb 3485
bf210566 3486 /////////////////////////////////////////////////////////////
3487 // Deallocating memory
3488 /////////////////////////////////////////////////////////////
3489 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3490 delete [] xvertexpoints[i];
3491 delete [] yvertexpoints[i];
3492 }
3493 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3494 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3495 delete vertex;
bf210566 3496 /////////////////////////////////////////////////////////////
d7599219 3497}
5bf92139 3498//_____________________________________________________________________________
3cf6a656 3499TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
44285dfa 3500 /////////////////////////////////////////////////////////////
bf210566 3501 // SSD Chip Assembly Generation
3502 /////////////////////////////////////////////////////////////
bf210566 3503 TGeoBBox* ssdchipcompshape[2];
3504 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3505 0.5*fgkSSDChipLength,
3506 0.5*fgkSSDChipWidth,
3507 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3508 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3509 0.5*fgkSSDChipLength,
3510 0.5*fgkSSDChipWidth,
3511 0.5*fgkSSDChipGlueHeight);
3512 TGeoVolume* ssdchipcomp[2];
3513 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3514 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3515 fSSDChipGlueMedium);
3516 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3517 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3518 TGeoTranslation* ssdchipcomptrans[2];
3519 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3520 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3521 /////////////////////////////////////////////////////////////
3522 // Virtual Volume containing SSDChip
3523 /////////////////////////////////////////////////////////////
3524 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3525 0.5*fgkSSDChipWidth,
3526 0.5*fgkSSDChipHeight);
e21cdd03 3527 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
bf210566 3528 /////////////////////////////////////////////////////////////
3529 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3cf6a656 3530 return ssdchip;
d7599219 3531}
bf210566 3532/////////////////////////////////////////////////////////////////////////////////
3533TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3534 /////////////////////////////////////////////////////////////
bf210566 3535 // Method returning a List containing pointers to Ladder Cable Volumes
cd2243fb 3536 //
3537 // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
3538 // each contains 2 volumes, one for polyamide and one for aluminium
44285dfa 3539 /////////////////////////////////////////////////////////////
bf210566 3540 const Int_t kladdercablesegmentnumber = 2;
3541 /////////////////////////////////////////
3542 // LadderSegmentBBox Volume
3543 /////////////////////////////////////////
160835d5 3544 static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
bf210566 3545 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3546 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
160835d5 3547
3548
3549 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3550 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3551 static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3552
3553 static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
3554 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3555 0.5*fgkSSDFlexWidth[0],
3556 0.5*fgkSSDLadderCableWidth,
3557 0.5*fgkSSDFlexHeight[0]),
3558 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3559 0.5*fgkSSDFlexWidth[0],
3560 0.5*fgkSSDLadderCableWidth,
3561 fgkSSDFlexHeight[0]
3562 +0.5*fgkSSDFlexHeight[1])
3563 };
3564 static TGeoVolume* laddercablesegmentbboxassembly = new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
3565 static TGeoVolume* laddercablesegmentarbassembly =
3566 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3567
3568 static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3569 static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3570
3571 if (laddercablesegmentbboxshape[0] == 0) {
3572 // Initialise static shapes and volumes
bf210566 3573 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3574 new TGeoBBox(laddercablesegmentbboxshapename[i],
3575 0.5*fgkSSDFlexWidth[0],
3576 0.5*fgkSSDLadderCableWidth,
3577 0.5*fgkSSDFlexHeight[i]);
160835d5 3578
bf210566 3579 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3580 laddercablesegmentbbox[i] =
3581 new TGeoVolume(laddercablesegmentbboxname[i],
3582 laddercablesegmentbboxshape[i],
3583 (i==0?fSSDAlTraceLadderCableMedium:
3584 fSSDKaptonLadderCableMedium));
3585 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3586 fColorPolyhamide);
3587 }
160835d5 3588
bf210566 3589 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3590 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3591 laddercablesegmentbboxtrans[i]);
3592/////////////////////////////////////////
3593// LadderSegmentArb8 Volume
3594/////////////////////////////////////////
3595 const Int_t kvertexnumber = 4;
3596 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3597 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3598 new TVector3*[kvertexnumber];
3599//Shape Vertex Positioning
3600 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3601 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3602 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3603 i*fgkSSDFlexHeight[0]);
3604 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3605 + fgkSSDFlexHeight[1]
3606 + i*fgkSSDFlexHeight[0]);
3607 laddercablesegmentvertexposition[i][3] =
3608 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3609 laddercablesegmentvertexposition[i][2]->Y());
3610 }
3611 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3612 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
a6e0ebfe 3613 const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
bf210566 3614 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
160835d5 3615
bf210566 3616 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3617 GetArbShape(laddercablesegmentvertexposition[i],
3618 laddercablesegmentwidth[i],
3619 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3620 laddercablesegmentarbshapename[i]);
3621 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3622 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
160835d5 3623
bf210566 3624 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3625 laddercablesegmentarb[i] =
3626 new TGeoVolume(laddercablesegmentarbname[i],
3627 laddercablesegmentarbshape[i],
3628 (i==0?fSSDAlTraceLadderCableMedium:
3629 fSSDKaptonLadderCableMedium));
3630 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3631 fColorPolyhamide);
d7599219 3632}
bf210566 3633 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3634 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3635 90.,90,-90.);
3636 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3637 0.,90.,0.);
3638 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3639 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3640 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3641 + fgkSSDFlexWidth[0],0.,0.,
3642 new TGeoRotation((*laddercablesegmentarbrot[1])
3643 *(*laddercablesegmentarbrot[0])));
bf210566 3644 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3645 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3646 laddercablesegmentarbcombitrans);
160835d5 3647 } // End of static initialisations
bf210566 3648/////////////////////////////////////////
3649// End Ladder Cable Volume
160835d5 3650// Note: this part depends explicitly on the length passed as an argument to the function
bf210566 3651/////////////////////////////////////////
3652 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3653 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3654 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3655 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3656 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3657 0.5*ssdendladdercablelength,
3658 0.5*fgkSSDLadderCableWidth,
3659 0.5*fgkSSDFlexHeight[i]);
3660 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3661 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3662 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3663 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3664 ladderendcablesegmentbbox[i] =
3665 new TGeoVolume(ladderendcablesegmentbboxname[i],
3666 ladderendcablesegmentbboxshape[i],
3667 (i==0?fSSDAlTraceLadderCableMedium:
3668 fSSDKaptonLadderCableMedium));
3669 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3670 fColorPolyhamide);
3671 }
3672 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3673 ladderendcablesegmentbboxtrans[0] =
3674 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
3675 0.5*ssdendladdercablelength,
3676 0.5*fgkSSDLadderCableWidth,
3677 0.5*fgkSSDFlexHeight[0]);
3678 ladderendcablesegmentbboxtrans[1] =
3679 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
3680 0.5*ssdendladdercablelength,
3681 0.5*fgkSSDLadderCableWidth,
3682 fgkSSDFlexHeight[0]
3683 +0.5*fgkSSDFlexHeight[1]);
3684 TGeoVolume* ladderendcablesegmentbboxassembly =
3685 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
3686 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3687 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
3688 ladderendcablesegmentbboxtrans[i]);
3689/////////////////////////////////////////
3690 TList* laddercablesegmentlist = new TList();
3691 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
3692 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
3693 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
3694 return laddercablesegmentlist;
160835d5 3695}
3696
bf210566 3697/////////////////////////////////////////////////////////////////////////////////
3698TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 3699 /////////////////////////////////////////////////////////////
cd2243fb 3700 // Method generating Ladder Cable of given length (n modules + end)
3701 // Called by GetLadderCableAssembly
44285dfa 3702 /////////////////////////////////////////////////////////////
bf210566 3703 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
3704 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
3705 for(Int_t i=0; i<n; i++){
3706 TGeoTranslation* laddercabletrans = new TGeoTranslation(
3707 i*(fgkCarbonFiberJunctionWidth),
3708 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3709 i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
3710 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
cd2243fb 3711 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
3712
d7599219 3713 }
bf210566 3714 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
3715 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
cd2243fb 3716 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3717 (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
bf210566 3718 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
3719 return laddercable;
3720}
3721/////////////////////////////////////////////////////////////////////////////////
3722TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
cd2243fb 3723 ///////////////////////////////////////////////////////////////////
3724 // Main method generating Ladder Cable bundles containing n cables
3725 ///////////////////////////////////////////////////////////////////
3726 Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
3727 Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1])};
3728 TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]),cableOrig);
3729 TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
a3f8715e 3730 char laddercabletransname[100];
bf210566 3731 for(Int_t i=0; i<n; i++){
3732 sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
cd2243fb 3733 laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
3734 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
d7599219 3735 }
cd2243fb 3736 return laddercable;
bf210566 3737}
3738/////////////////////////////////////////////////////////////////////////////////
3739TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
3740 /////////////////////////////////////////////////////////////
3741 // Method generating Ladder Cable List Assemblies
cd2243fb 3742 // containing two cables bundles, i.e. P+N readout for one endcap
bf210566 3743 /////////////////////////////////////////////////////////////
cd2243fb 3744 const Int_t kladdercableassemblynumber = 2;
bf210566 3745 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
3746 TGeoVolume* ladderCable[kladdercableassemblynumber];
a3f8715e 3747 char laddercableassemblyname[100];
bf210566 3748 TList* laddercableassemblylist = new TList();
3749 for(Int_t i=0; i<kladdercableassemblynumber; i++){
3750 sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
3751 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
3752 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
3753 new TGeoCombiTrans((n-1)
3754 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3755 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
3756 0.,new TGeoRotation("",180,0.,0.)));
3757 laddercableassemblylist->Add(ladderCable[i]);
3758}
3759 return laddercableassemblylist;
3760}
3761///////////////////////////////////////////////////////////////////////////////
3762void AliITSv11GeometrySSD::SetLadderSegment(){
3763 /////////////////////////////////////////////////////////////
3764 // Method Generating Ladder Segment Array
3765 /////////////////////////////////////////////////////////////
3766 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
3767 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
cd2243fb 3768
3769 /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
3770 TGeoXtru *laddersegmentshape = new TGeoXtru(2);
3771 static const Int_t ntrianglevtx = 3;
3772 Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
3773 Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
3774 laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
3775 laddersegmentshape->DefineSection(0,0);
3776 laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth); // MVL
3777 fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
3778 fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
3779 */
3780
bf210566 3781 if(!fCreateMaterials) CreateMaterials();
3782 if(!fTransformationMatrices) CreateTransformationMatrices();
3783 if(!fBasicObjects) CreateBasicObjects();
3784 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
3785 // Placing Carbon Fiber Support
3786 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
3787 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3788 fcarbonfibersupportmatrix[j]);
3789 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3790 fcarbonfibersupportmatrix[j]);
d7599219 3791 }
bf210566 3792 // Placing Carbon Fiber Junction
cd2243fb 3793 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
bf210566 3794 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
3795 fcarbonfiberjunctionmatrix[j]);
cd2243fb 3796 }
bf210566 3797 // Placing Carbon Fiber Lower Support
cd2243fb 3798 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
bf210566 3799 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
3800 fcarbonfiberlowersupportrans[j]);
cd2243fb 3801 }
bf210566 3802 // Placing SSD Sensor Support
3803 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
cd2243fb 3804 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
bf210566 3805 fssdsensorsupport[1][i],
3806 j+1,fssdsensorsupportmatrix[j]);
3807 // Placing SSD Cooling Tube Support
3808 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
3809 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3810 fcoolingtubesupportmatrix[j]);
3811 // Placing SSD Cooling Tube
cd2243fb 3812 fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
3813 fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
bf210566 3814 // Placing SSD Hybrid
3815 switch(i){
3816 case 0:
3817 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
3818 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3819 break;
3820 case 1:
3821 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
3822 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3823 break;
3824 }
3825 // Placing Cooling Block System
cd2243fb 3826 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
bf210566 3827 // Placing SSD Flex
cd2243fb 3828 for(Int_t j=0; j<fgkflexnumber; j++){
3829 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
3830 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
3831 }
bf210566 3832 }
d7599219 3833}
bf210566 3834///////////////////////////////////////////////////////////////////////////////
3835void AliITSv11GeometrySSD::SetEndLadderSegment(){
3836 /////////////////////////////////////////////////////////////
3837 // Method Generating End Ladder
3838 /////////////////////////////////////////////////////////////
3839 // End Ladder Carbon Fiber Junction
3840 /////////////////////////////////////////////////////////////
3841 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
3842 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
3843 if(!fCreateMaterials) CreateMaterials();
3844 if(!fTransformationMatrices) CreateTransformationMatrices();
3845 if(!fBasicObjects) CreateBasicObjects();
3846 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
3847 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
3848 fendladdersegment[i]->AddNode(j==2 ?
3849 fendladdercarbonfiberjunction[i][1] :
3850 fendladdercarbonfiberjunction[i][0],
3851 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
3852 }
3853 /////////////////////////////////////////////////////////////
3854 // End Ladder Carbon Fiber Support
3855 /////////////////////////////////////////////////////////////
3856 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
3857 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
3858 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3859 fendladdercarbonfibermatrix[i][j]);
3860 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3861 fendladdercarbonfibermatrix[i][j]);
3862 }
3863 /////////////////////////////////////////////////////////////
3864 // End Ladder Mounting Block
3865 /////////////////////////////////////////////////////////////
9b0c60ab 3866 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3867 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
e21cdd03 3868 fendladdermountingblockcombitrans[i]);
9b0c60ab 3869 /////////////////////////////////////////////////////////////
e5bf64ae 3870 // End Ladder Mounting Block Clip
9b0c60ab 3871 /////////////////////////////////////////////////////////////
3872 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3873 for(Int_t j=0; j<2; j++)
e21cdd03 3874 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
3875 fendladdermountingblockclipmatrix[i][j]);
bf210566 3876 /////////////////////////////////////////////////////////////
3877 // End Ladder Lower Supports
44285dfa 3878 /////////////////////////////////////////////////////////////
bf210566 3879 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
e21cdd03 3880 fendladderlowersupptrans[0]);
bf210566 3881 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
e21cdd03 3882 fendladderlowersupptrans[1]);
bf210566 3883 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
e21cdd03 3884 fendladderlowersupptrans[2]);
9b0c60ab 3885 /////////////////////////////////////////////////////////////
3886 // End Ladder Cooling Tube Support
3887 /////////////////////////////////////////////////////////////
3888 for(Int_t i=0; i<2; i++)
3889 for(Int_t j=0; j<(i==0?4:2); j++)
e21cdd03 3890 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3891 fendladdercoolingtubesupportmatrix[i][j]);
9b0c60ab 3892 /////////////////////////////////////////////////////////////
3893 // End Ladder Cooling Tube Support
3894 /////////////////////////////////////////////////////////////
cd2243fb 3895 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
3896 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
3897 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
3898 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
bf210566 3899}
3900///////////////////////////////////////////////////////////////////////////////
3901void AliITSv11GeometrySSD::SetLadder(){
3902 /////////////////////////////////////////////////////////////
3903 // Method Generating Ladder of Layer 5 and 6
44285dfa 3904 /////////////////////////////////////////////////////////////
bf210566 3905 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
3906 fgkSSDLay6SensorsNumber};
3907 /////////////////////////////////////////////////////////////////////////////
3908 /// Generating Ladder Mother Volume Containing Ladder
3909 /////////////////////////////////////////////////////////////////////////////
3910 TGeoXtru* laddershape[fgkladdernumber];
3911 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
3912 const Int_t kmothervertexnumber = 8;
3913 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
3914 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
3915 ///////////////////////
3916 // Setting the vertices
3917 ///////////////////////
3918 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
3919 * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
3920 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
0fb26117 3921 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
bf210566 3922 xmothervertex[0][1] = xmothervertex[0][0];
3923 ymothervertex[0][1] = 0.0;
3924 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
3925 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
3926 ymothervertex[0][2] = ymothervertex[0][1];
3927 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
3928 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
3929 xmothervertex[0][4] = -xmothervertex[0][3];
3930 ymothervertex[0][4] = ymothervertex[0][3];
3931 xmothervertex[0][5] = -xmothervertex[0][2];
3932 ymothervertex[0][5] = ymothervertex[0][2];
3933 xmothervertex[0][6] = -xmothervertex[0][1];
3934 ymothervertex[0][6] = ymothervertex[0][1];
3935 xmothervertex[0][7] = -xmothervertex[0][0];
3936 ymothervertex[0][7] = ymothervertex[0][0];
3937 for(Int_t i=0; i<kmothervertexnumber; i++){
3938 xmothervertex[1][i] = xmothervertex[0][i];
3939 ymothervertex[1][i] = ymothervertex[0][i];
3940 }
0fb26117 3941///////////////////////////////////////////////////////////////////////////
3942// Disalignement Mother Volume corrections 25/08/08
3943///////////////////////////////////////////////////////////////////////////
160835d5 3944 TGeoXtru* leftladdershape1[fgkladdernumber];
3945 TGeoXtru* leftladdershape2[fgkladdernumber];
0fb26117 3946 TGeoXtru* centersensorladdershape[fgkladdernumber];
160835d5 3947 TGeoXtru* rightladdershape1[fgkladdernumber];
3948 TGeoXtru* rightladdershape2[fgkladdernumber];
bf210566 3949 for(Int_t i=0; i<fgkladdernumber; i++){
160835d5 3950 leftladdershape1[i] = new TGeoXtru(2);
3951 leftladdershape2[i] = new TGeoXtru(2);
3952 centersensorladdershape[i] = new TGeoXtru(2);
3953 rightladdershape1[i] = new TGeoXtru(2);
3954 rightladdershape2[i] = new TGeoXtru(2);
3955 }
0fb26117 3956 //////////////////////////////////////
160835d5 3957 // Setting the names for shapes
0fb26117 3958 //////////////////////////////////////
160835d5 3959 leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
3960 leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
3961 leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
3962 leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
0fb26117 3963 centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
3964 centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
160835d5 3965 rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
3966 rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
3967 rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
3968 rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
0fb26117 3969 //////////////////////////////////////
160835d5 3970 Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
3971 Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
0fb26117 3972 Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
3973 Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
160835d5 3974 Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
3975 Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
3976 for(Int_t i=0; i<fgkladdernumber; i++) {
3977 for(Int_t j=0; j<kmothervertexnumber; j++){
3978 xcentersensorvertex[i][j] = xmothervertex[i][j];
3979 ycentersensorvertex[i][j] = ymothervertex[i][j];
3980 xend1laddervertex[i][j] = xmothervertex[i][j];
3981 yend1laddervertex[i][j] = ymothervertex[i][j];
3982 xend2laddervertex[i][j] = xmothervertex[i][j];
3983 yend2laddervertex[i][j] = ymothervertex[i][j];
3984 }
3985 // Add some space around sensors to accommodate misalignments
3986 xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
3987 xcentersensorvertex[i][1] = xcentersensorvertex[0][0];
3988 xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
3989 xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
3990
3991 ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
3992 ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
3993
3994 // Center Ladder Piece
3995 centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
3996 ycentersensorvertex[i]);
3997 centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3998 + 1.45*fgkSSDMountingBlockWidth);
3999 centersensorladdershape[i]->DefineSection(1, ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
4000 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4001 - 2.4*fgkSSDMountingBlockWidth);
0fb26117 4002
160835d5 4003 // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
0fb26117 4004
160835d5 4005 // Cuts off first corner (neg x)
4006 xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4007 xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
4008 // Cuts off last part (pos x)
4009 xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
4010 xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
0fb26117 4011
160835d5 4012 leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4013 yend1laddervertex[i]);
4014 leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4015 leftladdershape1[i]->DefineSection(1, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4016 - fgkEndLadderMountingBlockPosition[0]);
4017
4018 leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4019 yend2laddervertex[i]);
4020 leftladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4021 - fgkEndLadderMountingBlockPosition[0]);
4022 leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
4023 + 1.45*fgkSSDMountingBlockWidth); // connect to main volume at -1.6725 cm
4024
4025 rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4026 yend1laddervertex[i]);
4027 rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4028 +fgkEndLadderCarbonFiberLowerJunctionLength[0]
4029 -2.4*fgkSSDMountingBlockWidth);
4030 rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4031 + fgkEndLadderMountingBlockPosition[1]);
4032
4033 rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4034 yend2laddervertex[i]);
4035 rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4036 + fgkEndLadderMountingBlockPosition[1]);
4037 rightladdershape2[i]->DefineSection(1, ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4038 + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4039 }
4040 TGeoCompositeShape* laddershapecontainer[2];
4041 laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4042 "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4043 "+Lay5CenterSensorContainer"
4044 "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4045 laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4046 "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4047 "+Lay6CenterSensorContainer"
4048 "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4049 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4050 for(Int_t i=0; i<fgkladdernumber; i++){
4051 fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4052 fladder[i]->SetLineColor(4);
4053 }
bf210566 4054///////////////////////////////////////////////////////////////////////////
4055 if(!fCreateMaterials) CreateMaterials();
4056 if(!fTransformationMatrices) CreateTransformationMatrices();
4057 if(!fBasicObjects) CreateBasicObjects();
4058 SetLadderSegment();
4059 SetEndLadderSegment();
4060 for(Int_t i=0; i<fgkladdernumber; i++){
4061 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4062 //////////////////////////
4063 /// Placing Ladder Segment
4064 //////////////////////////
4065 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4066 fladdersegment[i==0 ? 1 : 0],
4067 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4068 //////////////////////////
4069 /// Placing SSD Sensor
4070 //////////////////////////
ca86fdb4 4071 if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
bf210566 4072 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4073 fssdsensormatrix[i][j]);
4074 }
4075 ///////////////////////////////
4076 /// Placing End Ladder Segment
4077 ///////////////////////////////
160835d5 4078 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
bf210566 4079 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4080 }
d7599219 4081/////////////////////////////////////////////////////////////////////////////
4082/// Placing Ladder Cables
4083/////////////////////////////////////////////////////////////////////////////
bf210566 4084 Int_t sidecablenumber[2][2];
4085 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4086 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4087 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4088 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4089 Double_t carbonfibertomoduleposition[3];
4090 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4091 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4092 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4093 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4094 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4095 - fgkSSDSensorCenterSupportThickness[0]);
4096 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4097 + 0.5*fgkCoolingTubeSupportHeight
4098 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4099 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4100 Double_t ssdendladdercablelength[4];
4101 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4102 + fgkSSDSensorLength
4103 - fgkSSDModuleStiffenerPosition[1]
4104 - fgkSSDStiffenerWidth
4105 - fgkSSDFlexWidth[0]
bf210566 4106 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4107 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4108 + fgkSSDModuleStiffenerPosition[1]
4109 + fgkSSDStiffenerWidth
bf210566 4110 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4111 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4112 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4113 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4114 - kendladdercablecorrection;
44285dfa 4115 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4116 + carbonfibertomoduleposition[1]
d7599219 4117 - fgkSSDModuleStiffenerPosition[1]
4118 - fgkSSDStiffenerWidth)
bf210566 4119 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
44285dfa 4120 TList* laddercableassemblylist[4];
4121 const Int_t kendladdercablesnumber = 4;
cd2243fb 4122 TGeoRotation *laddercablerot = new TGeoRotation();
4123 laddercablerot->SetAngles(90.,60.,-90.);
bf210566 4124 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4125 for(Int_t j=0; j<kendladdercablesnumber; j++){
4126 laddercableassemblylist[j] =
4127 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4128 ssdendladdercablelength[j]);
0fb26117 4129 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4130 j<2?1:2,fladdercablematrix[i][j]);
bf210566 4131 }
bf210566 4132}
4133////////////////////////////////////////////////////////////////////////////////
4134void AliITSv11GeometrySSD::SetLayer(){
d7599219 4135////////////////////////////////////////////////////////////////////////////////
bf210566 4136 // Creating Ladder of Layer 5 and Layer 6
4137 /////////////////////////////////////////////////////////////
4138 if(!fCreateMaterials) CreateMaterials();
4139 if(!fTransformationMatrices) CreateTransformationMatrices();
4140 if(!fBasicObjects) CreateBasicObjects();
4141 SetLadder(); // Generating the ladder of Layer5 and Layer6
4142 const Int_t kssdlayladdernumber[fgklayernumber] =
4143 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4144 /////////////////////////////////////////////////////////////
4145 // Generating mother volumes for Layer5 and Layer6
4146 /////////////////////////////////////////////////////////////
e5bf64ae 4147 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4148 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
bf210566 4149 Int_t *ladderindex[fgklayernumber];
4150 Int_t index[fgklayernumber] = {8,9};
4151 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4152 for(Int_t i=0; i<fgklayernumber; i++)
4153 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4154 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4155 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4156 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4157 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4158 }
44285dfa 4159 /////////////////////////////////////////////////////////////
bf210566 4160 // Deallocating memory
4161 /////////////////////////////////////////////////////////////
7b208ef4 4162 for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
d7599219 4163}
4164////////////////////////////////////////////////////////////////////////////////
4165void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4166 /////////////////////////////////////////////////////////////
4167 // Insert the layer 5 in the mother volume.
4168 /////////////////////////////////////////////////////////////
4169 if (! moth) {
160835d5 4170 AliError("Can't insert layer5, mother is null!\n");
44285dfa 4171 return;
4172 };
bf210566 4173 if(!fSSDLayer5) SetLayer();
4174 fMotherVol = moth;
4175 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4176 + fgkLay5CenterITSPosition);
4177 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4178 }
d7599219 4179////////////////////////////////////////////////////////////////////////////////
4180void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4181 /////////////////////////////////////////////////////////////
4182 // Insert the layer 6 in the mother volume.
4183 /////////////////////////////////////////////////////////////
4184 if (! moth) {
160835d5 4185 AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
44285dfa 4186 return;
4187 };
bf210566 4188 if(!fSSDLayer6) SetLayer();
4189 fMotherVol = moth;
4190 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4191 + fgkLay6CenterITSPosition);
4192 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4193 }
bf210566 4194 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4195 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4196 /////////////////////////////////////////////////////////////
4197 // Method generating the Arc structure of Ladder Support
4198 /////////////////////////////////////////////////////////////
4199 const Int_t kssdlayladdernumber[fgklayernumber] =
4200 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4201 Double_t mountingsupportedge[fgklayernumber];
4202 Double_t mountingblockratio[fgklayernumber];
4203 Double_t theta[fgklayernumber];
4204 Double_t phi[fgklayernumber];
4205 Double_t psi0[fgklayernumber];
4206 Double_t deltapsi[fgklayernumber];
4207 TVector3* mountingsupportedgevector[fgklayernumber];
4208 for(Int_t i=0; i<fgklayernumber; i++){
4209 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4210 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4211 * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4212 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4213 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4214 / kssdlayladdernumber[i])));
4215 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4216 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4217 mountingsupportedgevector[i] = new TVector3();
60e55aee 4218 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4219 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4220 (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4221 (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
9b0c60ab 4222 psi0[i] = 0.5*TMath::Pi()-phi[i];
4223 deltapsi[i] = (theta[i]+phi[i])/nedges;
4224 }
4225 TVector3** vertex[fgklayernumber];
4226 TList* vertexlist[fgklayernumber];
4227 Int_t indexedge[fgklayernumber] = {0,0};
4228 for(Int_t i=0; i<fgklayernumber; i++){
4229 vertex[i] = new TVector3*[nedges+1];
4230 vertexlist[i] = new TList();
4231 }
4232 for(Int_t i=0; i<fgklayernumber; i++){
4233 for(Int_t j=0; j<nedges+1; j++){
4234 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4235 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4236 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4237 vertexlist[i]->Add(vertex[i][j]);
4238 }
4239 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4240 }
4241 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4242 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4243 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4244 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4245 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4246 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4247 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4248 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4249 for(Int_t i=0; i<fgklayernumber; i++){
4250 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4251 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4252 xcentervertex[i] = new Double_t[indexedge[i]+3];
4253 ycentervertex[i] = new Double_t[indexedge[i]+3];
4254 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4255 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4256 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4257 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4258 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4259 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4260 ((TVector3*)vertexlist[i]->At(j))->X();
4261 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4262 ((TVector3*)vertexlist[i]->At(j))->Y();
4263 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4264 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4265 if(j<indexedge[i]+1){
4266 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4267 ((TVector3*)vertexlist[i]->At(j))->X();
4268 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4269 ((TVector3*)vertexlist[i]->At(j))->Y();
4270 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4271 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4272 }
4273 }
4274 xsidevertex[i][1] = xsidevertex[i][0];
4275 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4276 xsidevertex[i][2] = xsidevertex[i][3];
4277 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4278 xcentervertex[i][1] = xcentervertex[i][0];
4279 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4280 xcentervertex[i][2] = xcentervertex[i][3];
4281 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4282 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4283 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4284 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4285 ycenterlowervertex[i][0] = ysidevertex[i][0];
4286 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4287 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4288 }
4289 /////////////////////////////////////////////////////////////
4290 // Building the Arc Structure of Ladder Supports
4291 /////////////////////////////////////////////////////////////
4292 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4293 TGeoXtru* centermountingsupportshape[fgklayernumber];
4294 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4295 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4296 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4297 TGeoVolume* centermountingblocksupport[fgklayernumber];
4298 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4299 TGeoVolume* centerladdersupportpiece[fgklayernumber];
a3f8715e 4300 char sidemountingblockname[100];
4301 char centermountingblockname[100];
4302 char sideladdersupportpiecename[100];
4303 char centerladdersupportpiecename[100];
9b0c60ab 4304 for(Int_t i=0; i<fgklayernumber; i++){
4305 sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4306 sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4307 sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4308 sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4309 sidemountingblocksupportshape[i] = new TGeoXtru(2);
4310 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4311 xsidevertex[i],ysidevertex[i]);
4312 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4313 -fgkMountingBlockSupportWidth[0]);
4314 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4315 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4316 sidemountingblocksupportshape[i],
4317 fSSDAlCoolBlockMedium);
4318 sidemountingblocksupport[i]->SetLineColor(9);
4319 centermountingsupportshape[i] = new TGeoXtru(2);
4320 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4321 xcentervertex[i],ycentervertex[i]);
4322 centermountingsupportshape[i]->DefineSection(0,0.);
4323 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4324 -fgkMountingBlockSupportWidth[0]);
160835d5 4325
9b0c60ab 4326 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4327 centermountingsupportshape[i],
4328 fSSDAlCoolBlockMedium);
4329 centermountingblocksupport[i]->SetLineColor(9);
4330 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4331 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4332 xsidelowervertex[i],ysidelowervertex[i]);
4333 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4334 -fgkMountingBlockSupportWidth[0]);
4335 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4336 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4337 sideladdersupportpieceshape[i],
e21cdd03 4338 fSSDCarbonFiberMedium);
9b0c60ab 4339 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4340 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4341 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4342 xcenterlowervertex[i],ycenterlowervertex[i]);
4343 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4344 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4345 -fgkMountingBlockSupportWidth[0]);
4346 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4347 centerladdersupportpieceshape[i],
e21cdd03 4348 fSSDCarbonFiberMedium);
9b0c60ab 4349 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4350 }
4351 /////////////////////////////////////////////////////////////
4352 // Building the Up Structure of Ladder Supports
4353 /////////////////////////////////////////////////////////////
4354 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4355 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4356 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4357 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4358 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4359 //////////////////////////////////////////////////////////
4360 // Setting the volume for TGeoXtru Mounting Block Piece
4361 //////////////////////////////////////////////////////////
4362 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4363 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4364 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4365 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4366 TGeoVolume* mountingblockpieceup[fgklayernumber];
4367 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4368 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4369 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4370 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
a3f8715e 4371 char mountingblockpiecedownname[100];
4372 char mountingblockpieceupname[100];
9b0c60ab 4373 for(Int_t i=0; i<fgklayernumber; i++){
4374 ///////////////////////////
4375 // Mounting Block Down Vertex
4376 ///////////////////////////
4377 mountingblockpiecedownshape[i] = new TGeoXtru(2);
4378 sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4379 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4380 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4381 + fgkMountingBlockSupportDownHeight
4382 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4383 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4384 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4385 + fgkSSDMountingBlockHeight[1]
4386 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4387 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4388 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4389 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4390 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4391 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4392 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4393 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4394 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4395 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4396 + fgkSSDMountingBlockHeight[2]
4397 - fgkSSDMountingBlockHeight[0];
4398 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4399 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4400 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4401 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4402 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4403 mountingblockpiecedownyvertex[i]);
4404 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4405 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4406 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
e21cdd03 4407 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
9b0c60ab 4408 mountingblockpiecedown[i]->SetLineColor(fColorG10);
160835d5 4409
9b0c60ab 4410 ///////////////////////////
4411 // Mounting Block Up Vertex
4412 ///////////////////////////
4413 mountingblockpieceupshape[i] = new TGeoXtru(2);
4414 sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4415 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4416 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4417 + fgkMountingBlockSupportUpHeight[i]
4418 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4419 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4420 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4421 + fgkSSDMountingBlockHeight[1]
4422 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4423 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4424 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4425 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4426 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4427 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4428 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4429 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4430 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4431 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4432 + fgkSSDMountingBlockHeight[2]
4433 - fgkSSDMountingBlockHeight[0];
4434 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4435 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4436 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4437 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
160835d5 4438
9b0c60ab 4439 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4440 mountingblockpieceupyvertex[i]);
4441 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4442 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4443 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
e21cdd03 4444 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
9b0c60ab 4445 mountingblockpieceup[i]->SetLineColor(fColorG10);
4446 }
4447 ///////////////////////////////////////////////////////////////////
4448 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4449 ///////////////////////////////////////////////////////////////////
4450 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4451 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4452 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4453 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4454 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4455 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4456 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4457 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
a3f8715e 4458 char mountingblocksupportrapezoidowname[100];
4459 char mountingblocksupportrapezoidupname[100];
9b0c60ab 4460 Double_t scalefactor = 3./4.;
4461 for(Int_t i=0; i<fgklayernumber; i++){
4462 ////////////////////////////////////////////
4463 // Mounting Block Support Down Trapezoid Vertex
4464 ////////////////////////////////////////////
4465 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4466 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4467 - mountingsupportedge[i];
4468 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4469 mountingblocksupportrapezoidownxvertex[i][1] =
4470 mountingblocksupportrapezoidownxvertex[i][0];
4471 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4472 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4473 - mountingblockpiecedownyvertex[i][0]);
4474 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4475 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4476 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4477 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4478 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4479 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
160835d5 4480
9b0c60ab 4481 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4482 mountingblocksupportrapezoidownyvertex[i]);
4483 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4484 -fgkMountingBlockSupportWidth[0]);
4485 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4486 sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4487 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
e21cdd03 4488 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4489 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4490 ////////////////////////////////////////////
4491 // Mounting Block Support Up Trapezoid Vertex
4492 ////////////////////////////////////////////
4493 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4494 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4495 - mountingsupportedge[i];
4496 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4497 mountingblocksupportrapezoidupxvertex[i][1] =
4498 mountingblocksupportrapezoidupxvertex[i][0];
4499 mountingblocksupportrapezoidupyvertex[i][1] =
4500 mountingblockpieceupyvertex[i][0]
4501 + scalefactor*(mountingblockpieceupyvertex[i][1]
4502 - mountingblockpieceupyvertex[i][0]);
4503 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4504 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4505 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4506 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4507 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4508 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
160835d5 4509
9b0c60ab 4510 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4511 mountingblocksupportrapezoidupyvertex[i]);
4512 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4513 -fgkMountingBlockSupportWidth[0]);
4514 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4515 sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4516 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
e21cdd03 4517 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4518 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4519 }
4520 ///////////////////////////////////////////////////////////////////
4521 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4522 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4523 Double_t boxoriginup[fgklayernumber][2][3];
4524 Double_t boxorigindown[fgklayernumber][2][3];
a3f8715e 4525 char mountingblocksupportboxdownname[100];
4526 char mountingblocksupportboxupname[100];
9b0c60ab 4527 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4528 mountingblocksupportrot->SetAngles(90.,180.,-90);
4529 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4530 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4531 TGeoHMatrix* laddersupportmatrix[2];
4532 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4533 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4534 /////////////////////////////////////////////////////////////
4535 // Creating Mother Volume for Containment
4536 /////////////////////////////////////////////////////////////
4537 Double_t *xmothervertex[fgklayernumber];
4538 Double_t *ymothervertex[fgklayernumber];
4539 for(Int_t i=0; i<fgklayernumber; i++){
4540 xmothervertex[i] = new Double_t[8];
4541 ymothervertex[i] = new Double_t[8];
4542 }
4543 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4544 TGeoVolume* downmotherladdersupport[fgklayernumber];
4545 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
160835d5 4546 TGeoVolume* upmotherladdersupport[fgklayernumber];
a3f8715e 4547 char upmotheladdersupportname[100];
4548 char downmotheladdersupportname[100];
9b0c60ab 4549 for(Int_t i=0; i<fgklayernumber; i++){
4550 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4551 - mountingsupportedge[i];
4552 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4553 xmothervertex[i][1] = xmothervertex[i][0];
4554 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4555 + fgkMountingBlockSupportWidth[0];
4556 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4557 ymothervertex[i][2] = ymothervertex[i][1];
4558 xmothervertex[i][3] = xmothervertex[i][2];
4559 ymothervertex[i][3] = -ymothervertex[i][0];
4560 xmothervertex[i][4] = -xmothervertex[i][0];
4561 ymothervertex[i][4] = ymothervertex[i][3];
4562 xmothervertex[i][5] = xmothervertex[i][4];
4563 ymothervertex[i][5] = -ymothervertex[i][1];
4564 xmothervertex[i][6] = -xmothervertex[i][2];
4565 ymothervertex[i][6] = ymothervertex[i][5];
4566 xmothervertex[i][7] = xmothervertex[i][6];
4567 ymothervertex[i][7] = ymothervertex[i][0];
160835d5 4568
9b0c60ab 4569 sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4570 sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
160835d5 4571
4572 downmotherladdersupportshape[i] = new TGeoXtru(2);
9b0c60ab 4573 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4574 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
160835d5 4575 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
9b0c60ab 4576 + fgkMountingBlockSupportDownHeight
4577 + fgkSSDMountingBlockHeight[1]
4578 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4579 - fgkSSDModuleCoolingBlockToSensor
4580 - fgkSSDLadderVerticalDisalignment);
4581
4582// - fgkSSDModuleVerticalDisalignment);
4583 //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4584
4585 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4586 downmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4587 upmotherladdersupportshape[i] = new TGeoXtru(2);
4588 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4589 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4590 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4591 + fgkMountingBlockSupportUpHeight[i]
4592 + fgkSSDMountingBlockHeight[1]
4593 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4594 - fgkSSDModuleCoolingBlockToSensor
4595 - fgkSSDLadderVerticalDisalignment);
4596
4597 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4598 upmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4599 }
4600 for(Int_t i=0; i<fgklayernumber; i++){
4601 /////////////////////////
4602 // Setting the box origin
4603 /////////////////////////
4604 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4605 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4606 + 0.5*fgkMountingBlockSupportDownHeight
4607 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4608 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4609 - 0.5*fgkMountingBlockSupportWidth[0];
4610
4611 boxorigindown[i][1][0] = 0.0;
4612 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4613 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4614 - fgkMountingBlockSupportWidth[0]);
4615
4616 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4617 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4618 + 0.5*fgkMountingBlockSupportUpHeight[i]
4619 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4620 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4621 - 0.5*fgkMountingBlockSupportWidth[0];
4622
4623 boxoriginup[i][1][0] = 0.0;
160835d5 4624 boxoriginup[i][1][1] = boxoriginup[i][0][1];
9b0c60ab 4625 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4626 - fgkMountingBlockSupportWidth[0]);
4627
4628 /////////////////////////
4629 // Setting the boxes
4630 /////////////////////////
4631 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4632 + fgkSSDMountingBlockLength[0]),
160835d5 4633 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4634 0.5*fgkMountingBlockSupportWidth[0],
4635 boxorigindown[i][0]);
160835d5 4636 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4637 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4638 0.5*(fgkMountingBlockSupportWidth[1]
4639 - fgkMountingBlockSupportWidth[0]),
4640 boxorigindown[i][1]);
4641
4642 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4643 + fgkSSDMountingBlockLength[0]),
160835d5 4644 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4645 0.5*fgkMountingBlockSupportWidth[0],
4646 boxoriginup[i][0]);
160835d5 4647
9b0c60ab 4648 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
160835d5 4649 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4650 0.5*(fgkMountingBlockSupportWidth[1]
4651 - fgkMountingBlockSupportWidth[0]),
4652 boxoriginup[i][1]);
4653 ///////////////////////////////////////
160835d5 4654 // Adding the Volumes to Mother Volume
9b0c60ab 4655 ///////////////////////////////////////
4656 for(Int_t j=0; j<2; j++){
4657 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4658 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4659 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4660 mountingblocksupportboxdownshape[i][j],
e21cdd03 4661 fSSDCarbonFiberMedium);
9b0c60ab 4662 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4663 mountingblocksupportboxupshape[i][j],
e21cdd03 4664 fSSDCarbonFiberMedium);
9b0c60ab 4665 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4666 mountingblocksupportboxup[i][j]->SetLineColor(9);
4667 for(Int_t k=0; k<2; k++){
4668 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
160835d5 4669 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
9b0c60ab 4670 }
4671 }
4672 for(Int_t k=0; k<2; k++){
4673 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4674 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4675 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4676 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
160835d5 4677 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4678 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4679 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
160835d5 4680 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4681 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4682 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4683 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4684 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4685 }
4686 }
4687 TList* laddersupportlist = new TList();
4688 laddersupportlist->Add(downmotherladdersupport[0]);
4689 laddersupportlist->Add(upmotherladdersupport[0]);
4690 laddersupportlist->Add(downmotherladdersupport[1]);
4691 laddersupportlist->Add(upmotherladdersupport[1]);
4692 /////////////////////////////////////////////////////////////
4693 // Deallocating memory
4694 /////////////////////////////////////////////////////////////
4695 for(Int_t i=0; i<fgklayernumber; i++){
4696 for(Int_t j=0; j<nedges+1; j++)
4697 delete vertex[i][j];
4698 delete mountingsupportedgevector[i];
4699 delete [] vertex[i];
4700 delete vertexlist[i];
4701 delete [] xsidevertex[i];
4702 delete [] ysidevertex[i];
4703 delete [] xcentervertex[i];
4704 delete [] ycentervertex[i];
4705 delete [] xsidelowervertex[i];
4706 delete [] ysidelowervertex[i];
4707 delete [] xcenterlowervertex[i];
4708 delete [] ycenterlowervertex[i];
7b208ef4 4709 delete [] xmothervertex[i];
4710 delete [] ymothervertex[i];
9b0c60ab 4711 }
3e008bd7 4712 delete [] xsidevertex;
4713 delete [] ysidevertex;
4714 delete [] xcentervertex;
4715 delete [] ycentervertex;
4716 delete [] xsidelowervertex;
4717 delete [] ysidelowervertex;
4718 delete [] xcenterlowervertex;
4719 delete [] ycenterlowervertex;
9b0c60ab 4720 delete globalrefladdersupportrot;
4721 delete mountingblocksupportrot;
4722 /////////////////////
4723 return laddersupportlist;
4724}
4725 ////////////////////////////////////////////////////////////////////////////////
4726void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4727//////////////////////////////////////////
4728// Method Generating Ladder Support Ring
4729//////////////////////////////////////////
4730 if(!fCreateMaterials) CreateMaterials();
4731 if(!fTransformationMatrices) CreateTransformationMatrices();
4732 if(!fBasicObjects) CreateBasicObjects();
4733 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4734 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4735 const Int_t kssdlayladdernumber[fgklayernumber] =
4736 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4737 Double_t mountingsupportedge[fgklayernumber];
4738 Double_t mountingblockratio[fgklayernumber];
4739 Double_t theta[fgklayernumber];
4740 Double_t phi[fgklayernumber];
4741 for(Int_t i=0; i<fgklayernumber; i++){
4742 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4743 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4744 *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4745 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4746 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4747 / kssdlayladdernumber[i])));
4748 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4749 / fgkMountingBlockSupportRadius[i]);
4750 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4751 }
4752 TGeoRotation* globalrot = new TGeoRotation();
4753 globalrot->SetAngles(0.,-90.,0.);
4754 TGeoRotation** laddersupportrot[fgklayernumber];
4755 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4756 for(Int_t i=0; i<fgklayernumber; i++){
4757 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4758 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4759 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4760 laddersupportrot[i][j] = new TGeoRotation();
4761 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4762 switch(i){
4763 case 0: //Ladder of Layer5
4764 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4765 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4766 laddersupportmatrix[i][j]);
4767 break;
4768 case 1: //Ladder of Layer6
4769 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4770 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4771 laddersupportmatrix[i][j]);
4772 break;
4773 }
4774 }
4775 }
4776 /////////////////////////////////////////////////////////////
4777 // Creating Lower Ladder Support
4778 /////////////////////////////////////////////////////////////
4779 TVector3** ringsupportvertex[fgklayernumber];
4780 Double_t angle = 360./nedges;
4781 for(Int_t i=0; i<fgklayernumber; i++){
4782 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4783 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4784 * TMath::Cos(theta[i]));
4785 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4786 - mountingsupportedge[i],
4787 ringsupportvertex[i][0]->Y());
4788 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4789 ringsupportvertex[i][1]->Y());
4790 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4791 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4792 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4793 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4794 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4795 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4796 }
4797 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4798 for(Int_t j=0; j<nedges+1; j++){
4799 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
cd2243fb 4800 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
4801 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle));
9b0c60ab 4802 }
4803 }
4804 Double_t **xmothervertex = new Double_t*[fgklayernumber];
4805 Double_t **ymothervertex = new Double_t*[fgklayernumber];
4806 for(Int_t i=0; i<fgklayernumber; i++){
4807 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4808 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4809 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4810 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4811 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4812 }
4813 }
0e8760e5 4814////////////////////////////////////////////////////////////////////////////////
4815// Start Corrections 13/06/08
4816////////////////////////////////////////////////////////////////////////////////
a3f8715e 4817 char lowerladderpconsupportname[100];
0e8760e5 4818 TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4819 TGeoVolume* lowerladderpconsupport[fgklayernumber];
4820 Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4821 Double_t lowerladderpconradiusmax[fgklayernumber];
4822 Double_t lowerladderpconradiusmin[fgklayernumber];
4823 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4824 lowerladdersupportrot->SetAngles(90.,180.,-90);
4825 for(Int_t i=0; i<fgklayernumber; i++){
4826 lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4827 * TMath::Cos(theta[i]);
cd2243fb 4828 lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
0e8760e5 4829 }
4830 for(Int_t i=0; i<fgklayernumber; i++){
4831/////////////////////////// Modified Version ?///////////////////
4832 lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4833 for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
4834 lowerladderpconezsection[j],lowerladderpconradiusmin[i],
4835 lowerladderpconradiusmax[i]);
4836 sprintf(lowerladderpconsupportname,"LowerLadderPConSupportNameLay%d",i+5);
4837 lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
4838 lowerladderpconsupport[i]->SetLineColor(fColorAl);
4839 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
4840 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
4841 }
4842////////////////////////////////////////////////////////////////////////////////
4843// End Corrections 13/06/08
4844////////////////////////////////////////////////////////////////////////////////
4845 /*char lowerladdersupportname[30];
9b0c60ab 4846 TGeoXtru* lowerladdersupportshape[fgklayernumber];
4847 TGeoVolume* lowerladdersupport[fgklayernumber];
4848 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4849 lowerladdersupportrot->SetAngles(90.,180.,-90);
4850 for(Int_t i=0; i<fgklayernumber; i++){
4851 lowerladdersupportshape[i] = new TGeoXtru(2);
4852 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
4853 xmothervertex[i],ymothervertex[i]);
4854 lowerladdersupportshape[i]->DefineSection(0,0.);
4855 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4856 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
4857 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
4858 lowerladdersupportshape[i],fSSDSupportRingAl);
4859 lowerladdersupport[i]->SetLineColor(fColorAl);
4860 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
4861 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
0e8760e5 4862 }*/
9b0c60ab 4863 /////////////////////////////////////////////////////////////
4864 // Deallocating memory
4865 /////////////////////////////////////////////////////////////
4866 for(Int_t i=0; i<fgklayernumber; i++){
4867 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
4868 delete ringsupportvertex[i][j];
4869 delete [] ringsupportvertex[i];
4870 }
4871 for(Int_t i=0; i<fgklayernumber; i++){
4872 delete [] xmothervertex[i];
4873 delete [] ymothervertex[i];
4874 }
7b208ef4 4875 delete [] xmothervertex;
4876 delete [] ymothervertex;
9b0c60ab 4877 delete globalrot;
4878 for(Int_t i=0; i<fgklayernumber; i++){
4879 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
4880 delete laddersupportrot[i][j];
4881 delete [] laddersupportrot[i];
4882 }
4883 }
4884 ////////////////////////////////////////////////////////////////////////////////
4885 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
4886 /////////////////////////////////////////////////////////////
4887 // Method generating Endcap CoverPlate
4888 /////////////////////////////////////////////////////////////
4889 // Holes Definition
4890 ///////////////////
4891 Int_t nendcapcoverplateholedges = 30;
4892 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
4893 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
4894 0.5*fgkEndCapCoverPlateThickness};
851c0ce3 4895 TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
9b0c60ab 4896 nendcapcoverplateholedges,holesection);
4897 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 4898 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4899 endcapcoverplatesmallhole->SetLineColor(6);
851c0ce3 4900 TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
9b0c60ab 4901 nendcapcoverplateholedges,holesection);
4902 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 4903 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4904 endcapcoverplatebighole->SetLineColor(6);
4905 //////////////////////////
4906 // Screw Piece Definition
4907 //////////////////////////
4908 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
4909 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
4910 CosD(0.5*smallscrewangle),
4911 0.5*fgkEndCapCoverPlateThickness);
4912 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
4913 endcapsmallscrewpieceshape,
4914 fSSDCoolingTubePhynox);
4915 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
4916 ///////////////////
4917 // Box Definition
4918 ///////////////////
4919 TGeoBBox* endcapcoverplateboxshape[4];
4920 TGeoVolume* endcapcoverplatebox[4];
4921 Double_t boxorigin[5][3];
4922 boxorigin[0][0] = 0.;
4923 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
4924 boxorigin[0][2] = 0.;
4925
4926 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
4927 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
4928 boxorigin[1][2] = 0.;
4929
4930 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
4931 + fgkEndCapCoverPlateSmallHoleSeparation[1];
4932 boxorigin[2][1] = boxorigin[1][1];
4933 boxorigin[2][2] = 0.;
4934
4935 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
4936 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
4937 boxorigin[3][1] = boxorigin[1][1];
4938 boxorigin[3][2] = 0.;
4939
4940 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4941 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
4942 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
4943 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
4944
4945 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4946 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4947 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4948 + fgkEndCapCoverPlateSmallHoleRadius,
4949 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
4950
4951 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4952 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4953 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4954 + fgkEndCapCoverPlateSmallHoleRadius,
4955 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
4956
4957 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
4958 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4959 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4960 + fgkEndCapCoverPlateSmallHoleRadius,
4961 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
4962
4963 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 4964 fSSDAlCoolBlockMedium);
9b0c60ab 4965 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 4966 fSSDAlCoolBlockMedium);
9b0c60ab 4967 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 4968 fSSDAlCoolBlockMedium);
9b0c60ab 4969 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 4970 fSSDAlCoolBlockMedium);
9b0c60ab 4971 endcapcoverplatebox[0]->SetLineColor(6);
4972 endcapcoverplatebox[1]->SetLineColor(6);
4973 endcapcoverplatebox[2]->SetLineColor(6);
4974 endcapcoverplatebox[3]->SetLineColor(6);
4975 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
4976 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4977 fgkEndCapCoverPlateSmallHoleRadius,
4978 0.5*fgkEndCapCoverPlateThickness,
4979 endcapfillingboxorigin);
4980 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 4981 fSSDAlCoolBlockMedium);
9b0c60ab 4982 endcapfillingbox->SetLineColor(6);
4983 ////////////////////////////
851c0ce3 4984 // Contour shape Definition
9b0c60ab 4985 ////////////////////////////
4986 const Int_t kcontourvertexnumber = 10;
4987 Double_t xcontourvertex[kcontourvertexnumber];
4988 Double_t ycontourvertex[kcontourvertexnumber];
4989 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
4990 xcontourvertex[1] = xcontourvertex[0];
4991 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4992 xcontourvertex[3] = xcontourvertex[2];
4993 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
4994 xcontourvertex[5] = xcontourvertex[4];
4995 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4996 xcontourvertex[7] = xcontourvertex[6];
4997 xcontourvertex[8] = xcontourvertex[4];
4998 xcontourvertex[9] = xcontourvertex[8];
4999 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5000 - (kendcapcoverplatesmallholenumber[1]-1)
5001 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5002 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5003 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5004 ycontourvertex[2] = ycontourvertex[1];
5005 ycontourvertex[3] = ycontourvertex[0];
5006 ycontourvertex[4] = ycontourvertex[3];
5007 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5008 ycontourvertex[6] = ycontourvertex[5];
5009 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5010 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5011 + fgkEndCapCoverPlateSmallHoleRadius;
5012 ycontourvertex[8] = ycontourvertex[7];
5013 ycontourvertex[9] = ycontourvertex[0];
851c0ce3 5014
5015 Double_t xboxin, dxboxin, yboxin, dyboxin;
5016 Double_t xboxout, dxboxout, yboxout, dyboxout;
5017 Double_t coordmin, coordmax;
5018 coordmin = -fgkEndCapCoverPlateLength[0];
5019 coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5020 xboxout = 0.5*(coordmin+coordmax);
5021 dxboxout = 0.5*(coordmax-coordmin);
5022 coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5023 - (kendcapcoverplatesmallholenumber[1]-1)
5024 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5025 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5026 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5027 yboxout = 0.5*(coordmin+coordmax);
5028 dyboxout = 0.5*(coordmax-coordmin);
5029 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5030 coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5031 xboxin = 0.5*(coordmin+coordmax);
5032 dxboxin = 0.5*(coordmax-coordmin);
5033 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5034 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5035 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5036 + fgkEndCapCoverPlateSmallHoleRadius;
5037 yboxin = 0.5*(coordmin+coordmax);
5038 dyboxin = 0.5*(coordmax-coordmin);
5039 new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5040 TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5041 xboxout, yboxout, 0.);
5042 trendCapCoverPlateContourboxout->RegisterYourself();
5043 new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5044 TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5045 xboxin, yboxin, 0.);
5046 trendCapCoverPlateContourboxin->RegisterYourself();
5047 TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5048 "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5049
e21cdd03 5050 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5051 fSSDAlCoolBlockMedium);
9b0c60ab 5052 contour->SetLineColor(6);
5053 /////////////////////////////
851c0ce3 5054 // Hole Contour Shape Definition
9b0c60ab 5055 ////////////////////////////
851c0ce3 5056 coordmin = xcontourvertex[0];
5057 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5058 xboxout = 0.5*(coordmin+coordmax);
5059 dxboxout = 0.5*(coordmax-coordmin);
5060 coordmin = ycontourvertex[1];
5061 coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5062 yboxout = 0.5*(coordmin+coordmax);
5063 dyboxout = 0.5*(coordmax-coordmin);
5064 coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5065 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5066 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5067 xboxin = 0.5*(coordmin+coordmax);
5068 dxboxin = 0.5*(coordmax-coordmin);
5069 coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5070 - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5071 coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5072 yboxin = 0.5*(coordmin+coordmax);
5073 dyboxin = 0.5*(coordmax-coordmin);
5074 new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5075 TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5076 xboxout, yboxout, 0.);
5077 trendCapCoverPlateContourboxout1->RegisterYourself();
5078 new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5079 TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5080 xboxin, yboxin, 0.);
5081 trendCapCoverPlateContourboxin1->RegisterYourself();
5082 TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5083 "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5084
5085
5086 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5087 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5088 xboxout = 0.5*(coordmin+coordmax);
5089 dxboxout = 0.5*(coordmax-coordmin);
5090 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5091 - fgkEndCapCoverPlateWidth[0]);
5092 coordmax = ycontourvertex[0];
5093 yboxout = 0.5*(coordmin+coordmax);
5094 dyboxout = 0.5*(coordmax-coordmin);
5095 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5096 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5097 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5098 xboxin = 0.5*(coordmin+coordmax);
5099 dxboxin = 0.5*(coordmax-coordmin);
5100 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5101 - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5102 - fgkEndCapCoverPlateWidth[0]
5103 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5104 coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5105 yboxin = 0.5*(coordmin+coordmax);
5106 dyboxin = 0.5*(coordmax-coordmin);
5107 new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5108 TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5109 xboxout, yboxout, 0.);
5110 trendCapCoverPlateContourboxout2->RegisterYourself();
5111 new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5112 TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5113 xboxin, yboxin, 0.);
5114 trendCapCoverPlateContourboxin2->RegisterYourself();
5115 TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5116 "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5117
5118// const Int_t kholecontourvertexnumber = 10;
5119
9b0c60ab 5120 Double_t xholecontourvertex[2][kcontourvertexnumber];
5121 Double_t yholecontourvertex[2][kcontourvertexnumber];
5122 xholecontourvertex[0][0] = xcontourvertex[0];
5123 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5124 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5125 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5126 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5127 + 0.5*(fgkEndCapCoverPlateLength[2]
5128 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5129 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5130 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5131 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5132 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5133 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5134 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5135
5136 yholecontourvertex[0][0] = ycontourvertex[1];
5137 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5138 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5139 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5140 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5141 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5142 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5143 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5144 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5145 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5146 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5147
5148 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5149 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5150 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5151 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5152 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5153 + 0.5*(fgkEndCapCoverPlateLength[2]
5154 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5155 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5156 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5157 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5158 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5159 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5160 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5161
5162 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5163 - fgkEndCapCoverPlateWidth[0]);
5164 yholecontourvertex[1][1] = ycontourvertex[0];
5165 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5166 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5167 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5168 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5169 - fgkEndCapCoverPlateWidth[0]
5170 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5171 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5172 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5173 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5174 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5175
9b0c60ab 5176 TGeoVolume* holecontour[2];
851c0ce3 5177 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
e21cdd03 5178 fSSDAlCoolBlockMedium);
9b0c60ab 5179 holecontour[0]->SetLineColor(6);
851c0ce3 5180 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
e21cdd03 5181 fSSDAlCoolBlockMedium);
9b0c60ab 5182 holecontour[1]->SetLineColor(6);
5183 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5184 + fgkEndCapCoverPlateLength[2],0.,0.);
5185 TGeoTranslation* bigholetrans[3];
5186 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5187 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5188 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5189 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5190 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5191 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5192 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5193 /////////////////////////////////
5194 // Mother Volume Xtru Definition
5195 /////////////////////////////////
5196 const Int_t kmothervertexnumber = 12;
5197 Double_t xmothervertex[kmothervertexnumber];
5198 Double_t ymothervertex[kmothervertexnumber];
5199 xmothervertex[0] = xcontourvertex[0];
5200 xmothervertex[1] = xmothervertex[0];
5201 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5202 xmothervertex[3] = xmothervertex[2];
5203 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5204 xmothervertex[5] = xmothervertex[4];
5205 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5206 xmothervertex[7] = xmothervertex[6];
5207 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5208 + fgkEndCapCoverPlateLength[2];
5209 xmothervertex[9] = xmothervertex[8];
5210 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5211 xmothervertex[11] = xmothervertex[10];
5212
5213 ymothervertex[0] = ycontourvertex[0];
5214 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5215 ymothervertex[2] = ymothervertex[1];
5216 ymothervertex[3] = ycontourvertex[1];
5217 ymothervertex[4] = ymothervertex[3];
5218 ymothervertex[5] = ymothervertex[1];
5219 ymothervertex[6] = ymothervertex[5];
5220 ymothervertex[7] = ymothervertex[0];
5221 ymothervertex[8] = ymothervertex[7];
5222 ymothervertex[9] = ymothervertex[8]
5223 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5224 ymothervertex[10] = ymothervertex[9];
5225 ymothervertex[11] = ymothervertex[8];
5226 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5227 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5228 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5229 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5230 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5231 ////////////////////////////////////////
5232 // Adding Nodes
5233 ////////////////////////////////////////
5234// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5235 TGeoTranslation*** endcapcoverplatesmallholetrans;
5236 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5237 Double_t transx[4] = {0,
5238 fgkEndCapCoverPlateSmallHoleSeparation[0],
5239 fgkEndCapCoverPlateSmallHoleSeparation[0]
5240 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5241 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5242 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5243 Int_t index = 0;
5244 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5245 endcapcoverplatesmallholetrans[i] =
5246 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5247 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5248 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5249 endcapcoverplatesmallholetrans[i][j] =
5250 new TGeoTranslation(transx[i],
5251 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5252 if(index!=10){
5253 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5254 index,endcapcoverplatesmallholetrans[i][j]);
5255 mothercoverplate->AddNode(endcapsmallscrewpiece,
5256 index,endcapcoverplatesmallholetrans[i][j]);
5257 }
5258 if(j<kendcapcoverplatesmallholenumber[1]-1)
5259 mothercoverplate->AddNode(endcapcoverplatebox[0],
5260 index,endcapcoverplatesmallholetrans[i][j]);
5261 }
5262 }
5263 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5264 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5265 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5266 mothercoverplate->AddNode(endcapfillingbox,1);
5267 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5268 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5269 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5270 mothercoverplate->AddNode(holecontour[0],1);
5271 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5272 mothercoverplate->AddNode(holecontour[1],1);
5273 mothercoverplate->AddNode(contour,1);
5274 /////////////////////////////////
5275 return mothercoverplate;
5276 }
5277 ////////////////////////////////////////////////////////////////////////////////
5278 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5279 /////////////////////////////////////////////////////////////
5280 // Getting EndCap Cooling Tube
5281 /////////////////////////////////////////////////////////////
5282 TGeoTorus* endcapcoolingtubetorushape[5];
5283 TGeoVolume* endcapcoolingtubetorus[5];
5284 TGeoTube* endcapcoolingtubeshape[4];
5285 TGeoVolume* endcapcoolingtube[4];
a3f8715e 5286 char endcapcoolingtubetorusname[100];
5287 char endcapcoolingtubename[100];
9b0c60ab 5288 TGeoTorus* endcapcoolingwatertubetorushape[5];
5289 TGeoVolume* endcapcoolingwatertubetorus[5];
5290 TGeoTube* endcapcoolingwatertubeshape[4];
5291 TGeoVolume* endcapcoolingwatertube[4];
a3f8715e 5292 char endcapcoolingwatertubetorusname[100];
5293 char endcapcoolingwatertubename[100];
9b0c60ab 5294 for(Int_t i=0; i<5; i++){
5295 sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5296 sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5297 sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5298 sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5299 if(i==3){
5300 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5301 fgkEndCapCoolingTubeRadiusMin,
5302 fgkEndCapCoolingTubeRadiusMax,
5303 90.0,fgkEndCapCoolingTubeAngle[3]);
5304 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5305 0.,fgkEndCapCoolingTubeRadiusMin,
5306 90.0,fgkEndCapCoolingTubeAngle[3]);
5307 }
5308 else{
5309 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5310 :fgkEndCapCoolingTubeAxialRadius[1],
5311 fgkEndCapCoolingTubeRadiusMin,
5312 fgkEndCapCoolingTubeRadiusMax,
5313 0.,fgkEndCapCoolingTubeAngle[i]);
5314 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5315 :fgkEndCapCoolingTubeAxialRadius[1],
5316 0.,fgkEndCapCoolingTubeRadiusMin,
5317 0.,fgkEndCapCoolingTubeAngle[i]);
5318 }
5319 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5320 endcapcoolingtubetorushape[i],
5321 fSSDCoolingTubePhynox);
5322 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5323 endcapcoolingwatertubetorushape[i],
5324 fSSDCoolingTubeWater);
5325 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5326 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5327 if(i<4){
5328 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5329 fgkEndCapCoolingTubeRadiusMax,
5330 0.5*fgkEndCapCoolingTubeLength[i]);
5331 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5332 0.5*fgkEndCapCoolingTubeLength[i]);
5333 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5334 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5335 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5336 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5337 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5338 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5339 }
5340 }
5341 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5342 /////////////////////////////////////////
5343 // Transformation for Volume Positioning
5344 /////////////////////////////////////////
5345 TGeoCombiTrans* coolingtubecombitrans[6];
5346 TGeoRotation* coolingtuberot[8];
5347 TGeoTranslation* coolingtubetrans[6];
5348 TGeoHMatrix* coolingtubematrix[4];
5349 TGeoCombiTrans* torustubecombitrans[4];
5350 TGeoRotation* torustuberot[7];
5351 TGeoTranslation* torustubetrans[4];
5352 TGeoHMatrix* torustubematrix[5];
5353 TGeoCombiTrans* coolingwatertubecombitrans[6];
5354 TGeoRotation* coolingwatertuberot[8];
5355 TGeoTranslation* coolingwatertubetrans[6];
5356 TGeoHMatrix* coolingwatertubematrix[4];
5357 TGeoCombiTrans* toruswatertubecombitrans[4];
5358 TGeoRotation* toruswatertuberot[7];
5359 TGeoTranslation* toruswatertubetrans[4];
5360 TGeoHMatrix* toruswatertubematrix[5];
5361 for(Int_t i=0; i<8; i++){
5362 if(i<6){
5363 coolingtubetrans[i] = new TGeoTranslation();
5364 coolingwatertubetrans[i] = new TGeoTranslation();
5365 }
5366 if(i<8){
5367 coolingtuberot[i] = new TGeoRotation();
5368 coolingwatertuberot[i] = new TGeoRotation();
5369 }
5370 if(i<4){
5371 torustubetrans[i] = new TGeoTranslation();
5372 toruswatertubetrans[i] = new TGeoTranslation();
5373 }
5374 if(i<7){
5375 torustuberot[i] = new TGeoRotation();
5376 toruswatertuberot[i] = new TGeoRotation();
5377 }
5378 }
5379 /////////////////////////////////////////
5380 // Transformation for Inox Volume Positioning
5381 /////////////////////////////////////////
5382 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5383 -endcapcoolingtubeshape[0]->GetDz(),0.);
5384 coolingtuberot[0]->SetAngles(0.,90.,0.);
5385 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5386 *coolingtuberot[0]);
5387
5388 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5389 coolingtuberot[1]->SetAngles(0.,90.,0.);
5390 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5391 *coolingtuberot[1]);
5392
5393 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5394 *CosD(fgkEndCapCoolingTubeAngle[0]),
5395 fgkEndCapCoolingTubeAxialRadius[0]
5396 *SinD(fgkEndCapCoolingTubeAngle[0]),
5397 0.);
5398 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5399 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5400 *coolingtuberot[2]);
5401
5402 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5403 * (*coolingtubecombitrans[1]));
5404
5405 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5406 endcapcoolingtubeshape[1]->GetDz());
5407 torustuberot[0]->SetAngles(0.,90.,0.);
5408 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5409
5410 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5411
5412 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5413 -endcapcoolingtubeshape[2]->GetDz(),0.);
5414 coolingtuberot[3]->SetAngles(0.,90.,0.);
5415 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5416 *coolingtuberot[3]);
5417 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5418 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5419 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5420
5421 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5422 endcapcoolingtubeshape[2]->GetDz());
5423 torustuberot[1]->SetAngles(0.,90.,0.);
5424 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5425 torustuberot[2]->SetAngles(180.,0.,0.);
5426 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5427 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5428
5429 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5430 -fgkEndCapCoolingTubeAxialRadius[0]);
5431 torustuberot[3]->SetAngles(0.,90.,0.);
5432 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5433 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5434 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5435 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5436
5437 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5438 fgkEndCapCoolingTubeAxialRadius[0],0.);
5439 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5440 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5441 *coolingtuberot[5]);
5442 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5443 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5444 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5445
5446 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5447 endcapcoolingtubeshape[0]->GetDz());
5448 torustuberot[5]->SetAngles(0.,90.,0.);
5449 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5450 torustuberot[6]->SetAngles(-90.,0.,0.);
5451 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5452 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5453
5454 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5455 endcapcoolingtubeshape[3]->GetDz(),0.);
5456 coolingtuberot[6]->SetAngles(0.,90.,0.);
5457 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5458 *coolingtuberot[6]);
5459 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5460 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5461 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5462 /////////////////////////////////////////
5463 // Transformation for Water Volume Positioning
5464 /////////////////////////////////////////
5465 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5466 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5467 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5468 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5469 *coolingwatertuberot[0]);
5470
5471 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5472 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5473 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5474 *coolingwatertuberot[1]);
5475
5476 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5477 *CosD(fgkEndCapCoolingTubeAngle[0]),
5478 fgkEndCapCoolingTubeAxialRadius[0]
5479 *SinD(fgkEndCapCoolingTubeAngle[0]),
5480 0.);
5481 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5482 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5483 *coolingwatertuberot[2]);
5484
5485 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5486 * (*coolingwatertubecombitrans[1]));
5487
5488 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5489 endcapcoolingwatertubeshape[1]->GetDz());
5490 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5491 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5492 *toruswatertuberot[0]);
5493
5494 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5495 * (*toruswatertubecombitrans[0]));
5496
5497 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5498 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5499 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5500 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5501 *coolingwatertuberot[3]);
5502 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5503 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5504 * (*coolingwatertubecombitrans[3]));
5505 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5506
5507 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5508 endcapcoolingwatertubeshape[2]->GetDz());
5509 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5510 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5511 *toruswatertuberot[1]);
5512 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5513 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5514 * (*toruswatertubecombitrans[1]));
5515 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5516
5517 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5518 -fgkEndCapCoolingTubeAxialRadius[0]);
5519 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5520 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5521 *toruswatertuberot[3]);
5522 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5523 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5524 * (*toruswatertubecombitrans[2]));
5525 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5526
5527 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5528 fgkEndCapCoolingTubeAxialRadius[0],0.);
5529 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5530 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5531 *coolingwatertuberot[5]);
5532 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5533 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5534 * (*coolingwatertubecombitrans[4]));
5535 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5536
5537 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5538 endcapcoolingwatertubeshape[0]->GetDz());
5539 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5540 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5541 *toruswatertuberot[5]);
5542 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5543 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5544 * (*toruswatertubecombitrans[3]));
5545 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5546
5547 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5548 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5549 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5550 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5551 *coolingwatertuberot[6]);
5552 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5553 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5554 * (*coolingwatertubecombitrans[5]));
5555 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5556 /////////////////////////////////////////
5557 // Positioning Volumes
5558 /////////////////////////////////////////
5559 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5560 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5561
5562 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5563 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5564
5565 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5566 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5567
5568 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5569 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5570
5571 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5572 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5573
5574 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5575 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5576
5577 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5578 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5579
5580 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5581 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5582
5583 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5584 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5585
5586 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5587 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5588 /////////////////////////////////////////////////////////////
5589 // Deallocating memory
5590 /////////////////////////////////////////////////////////////
5591 for(Int_t i=0; i<8; i++){
5592 if(i<6){
5593 delete coolingtubetrans[i];
5594 delete coolingwatertubetrans[i];
5595 if(i!=0){
5596 delete coolingtubecombitrans[i];
5597 delete coolingwatertubecombitrans[i];
5598 }
5599 }
5600 if(i<8){
5601 delete coolingtuberot[i];
5602 delete coolingwatertuberot[i];
5603 }
5604 if(i<4){
5605 delete torustubetrans[i];
5606 delete toruswatertubetrans[i];
5607 delete torustubecombitrans[i];
5608 delete toruswatertubecombitrans[i];
5609 }
5610 if(i<7){
5611 delete torustuberot[i];
5612 delete toruswatertuberot[i];
5613 }
5614 }
5615 /////////////////////////////////////////////////////////////
5616 return endcapcoolingtubemother;
5617 }
5618 ////////////////////////////////////////////////////////////////////////////////
5619 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5620 /////////////////////////////////////////////////////////////
5621 // Getting EndCap Cover Side
5622 /////////////////////////////////////////////////////////////
5623 const Int_t kendcapcoverholenumber[2] = {7,5};
5624 const Int_t kvertexnumber = 15;
5625 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5626 xvertex[0] = 0.0;
5627 xvertex[1] = xvertex[0];
5628 xvertex[2] = fgkEndCapSideCoverLength[0];
5629 xvertex[3] = fgkEndCapSideCoverLength[1];
5630 xvertex[4] = xvertex[3];
5631 xvertex[5] = fgkEndCapSideCoverLength[2];
5632 xvertex[6] = xvertex[5];
5633 xvertex[7] = xvertex[2];
5634 xvertex[8] = xvertex[7];
5635 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5636 xvertex[10] = xvertex[9];
5637 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5638 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5639 * fgkEndCapSideCoverLength[4];
5640 xvertex[12] = xvertex[11];
5641 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5642 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5643 * fgkEndCapSideCoverLength[4];
5644 xvertex[14] = xvertex[13];
5645 yvertex[0] = 0.0;
5646 yvertex[1] = fgkEndCapSideCoverWidth[0];
5647 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5648 yvertex[3] = yvertex[2];
5649 yvertex[4] = fgkEndCapSideCoverWidth[1];
5650 yvertex[5] = yvertex[4];
5651 yvertex[6] = yvertex[0];
5652 yvertex[7] = yvertex[6];
5653 yvertex[8] = fgkEndCapSideCoverWidth[6];
5654 yvertex[9] = yvertex[8];
5655 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5656 yvertex[11] = yvertex[10];
5657 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5658 yvertex[13] = yvertex[12];
5659 yvertex[14] = yvertex[6];
851c0ce3 5660 TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5661 endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5662 endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5663 endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5664 endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5665 TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5666 endcapsidecovershapein->SetName("endcapsidecovershapein");
5667 endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5668 endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5669 endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5670
5671
5672 TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
9b0c60ab 5673 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5674 endcapsidecovershape,fSSDCoolingTubePhynox);
5675 endcapsidecover->SetLineColor(fColorPhynox);
5676 ////////////////////////////////////////////
5677 // Defininition of Mother Volume
5678 ////////////////////////////////////////////
5679 const Int_t kmothervertexnumber = 7;
5680 Double_t xmothervertex[kmothervertexnumber];
5681 Double_t ymothervertex[kmothervertexnumber];
5682 for(Int_t i=0; i<kmothervertexnumber; i++){
5683 xmothervertex[i] = xvertex[i];
5684 ymothervertex[i] = yvertex[i];
5685 }
5686 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5687 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5688 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5689 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5690 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5691 endcapsidecovermothershape,fSSDAir);
5692 ////////////////////////////////////////////
5693 endcapsidecovermother->AddNode(endcapsidecover,1);
5694 TGeoBBox* endcapsidecoverboxshape[4];
5695 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5696 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5697 0.5*fgkEndCapSideCoverLength[4],
5698 0.5*fgkEndCapSideCoverThickness);
5699 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5700 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5701 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5702 - fgkEndCapSideCoverLength[4]),
5703 0.5*fgkEndCapSideCoverThickness);
5704 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5705 0.5*fgkEndCapSideCoverLength[4],
5706 0.5*fgkEndCapSideCoverThickness);
5707 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5708 0.5*fgkEndCapSideCoverWidth[5],
5709 0.5*fgkEndCapSideCoverThickness);
5710 TGeoVolume* endcapsidecoverbox[4];
5711 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5712 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5713 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5714 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5715 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5716// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5717 TGeoTranslation** endcapsidecoverboxtrans;
5718 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5719 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5720 + fgkEndCapSideCoverLength[0],
5721 endcapsidecoverboxshape[0]->GetDY()
5722 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5723 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5724 + xvertex[11],
5725 endcapsidecoverboxshape[1]->GetDY()
5726 + yvertex[12],0.);
5727 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5728 + xvertex[11],
5729 endcapsidecoverboxshape[2]->GetDY()
5730 + yvertex[12]
5731 + 2.*endcapsidecoverboxshape[1]->GetDY()
5732 + fgkEndCapSideCoverWidth[5],0.);
5733 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5734 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5735 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5736 for(Int_t i=0; i<2; i++)
5737 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5738 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5739 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5740 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5741 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5742 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5743 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5744 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5745 }
5746 for(Int_t i=0; i<2; i++)
5747 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5748 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5749 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5750 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5751 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5752 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5753 +fgkEndCapSideCoverLength[4]),0.0);
5754 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5755 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5756 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5757 +i*(kendcapcoverholenumber[1]-1)+j]);
5758 }
5759 return endcapsidecovermother;
5760 }
5761 ////////////////////////////////////////////////////////////////////////////////
5762 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5763 ////////////////////////////////////////////////////////////////////////////////
5764 // Method returning Interface Card A, Interface Card B, Supply Card
5765 ////////////////////////////////////////////////////////////////////////////////
5766 /////////////////////
5767 // Supply Card
5768 /////////////////////
5769 // Electronic Board Back Al Plane
5770 const Int_t kelectboardbackvertexnumber = 8;
5771 Double_t xelectboardback[kelectboardbackvertexnumber];
5772 Double_t yelectboardback[kelectboardbackvertexnumber];
5773 xelectboardback[0] = 0.0;
5774 xelectboardback[1] = xelectboardback[0];
5775 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5776 xelectboardback[3] = xelectboardback[2];
5777 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5778 xelectboardback[5] = xelectboardback[4];
5779 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5780 xelectboardback[7] = xelectboardback[6];
5781
5782 yelectboardback[0] = 0.0;
5783 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5784 yelectboardback[2] = yelectboardback[1];
5785 yelectboardback[3] = yelectboardback[0];
5786 yelectboardback[4] = yelectboardback[3];
5787 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5788 yelectboardback[6] = yelectboardback[5];
5789 yelectboardback[7] = yelectboardback[4];
5790 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5791 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5792 xelectboardback,yelectboardback);
5793 electboardbackshape->DefineSection(0,0.0);
5794 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5795 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5796 electboardbackshape,fSSDSupportRingAl);
5797 electboardback->SetLineColor(fColorAl);
5798 // Electronic Board Kapton Layer
5799 const Int_t kelectlayervertexnumber = 8;
5800 Double_t xelectlayer[kelectlayervertexnumber];
5801 Double_t yelectlayer[kelectlayervertexnumber];
5802 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5803 xelectlayer[1] = xelectlayer[0];
5804 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5805 xelectlayer[3] = xelectlayer[2];
5806 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5807
5808 yelectlayer[0] = 0.0;
5809 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5810 yelectlayer[2] = yelectlayer[1];
5811 yelectlayer[3] = yelectlayer[0];
5812 yelectlayer[4] = yelectlayer[3];
5813 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5814 yelectlayer[6] = yelectlayer[5];
5815 yelectlayer[7] = yelectlayer[4];
5816 TGeoXtru* electlayershape = new TGeoXtru(2);
5817 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5818 electlayershape->DefineSection(0,0.0);
5819 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5820 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5821 electlayershape,fSSDKaptonFlexMedium);
5822 electlayer->SetLineColor(fColorKapton);
5823 // JMD Connector Female
5824 const Int_t kjmdconnectorvertexnumber = 6;
5825 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5826 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5827 xjmdconnectorvertex[0] = 0.0;
5828 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5829 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5830 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5831 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5832 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5833
5834 yjmdconnectorvertex[0] = 0.0;
5835 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5836 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5837 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5838 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5839 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5840 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5841 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5842 yjmdconnectorvertex);
5843 jmdconnectorshape->DefineSection(0,0.0);
5844 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5845 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5846 jmdconnectorshape,fSSDMountingBlockMedium);
5847 jmdconnector->SetLineColor(fColorG10);
5848 // Top Cable Connector
5849 const Int_t kcableconnectorvertexnumber = 8;
5850 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5851 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5852 xconnectorvertex[0] = 0.0;
5853 xconnectorvertex[1] = xconnectorvertex[0];
5854 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5855 xconnectorvertex[3] = xconnectorvertex[2];
5856 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5857 - fgkEndCapCardCableConnectorLength[2];
5858 xconnectorvertex[5] = xconnectorvertex[4];
5859 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5860 xconnectorvertex[7] = xconnectorvertex[6];
5861
5862 yconnectorvertex[0] = 0.0;
5863 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5864 yconnectorvertex[2] = yconnectorvertex[1];
5865 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5866 yconnectorvertex[4] = yconnectorvertex[3];
5867 yconnectorvertex[5] = yconnectorvertex[1];
5868 yconnectorvertex[6] = yconnectorvertex[5];
5869 yconnectorvertex[7] = yconnectorvertex[0];
5870 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5871 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5872 yconnectorvertex);
5873 cableconnectorshape->DefineSection(0,0.0);
5874 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5875 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5876 cableconnectorshape,fSSDMountingBlockMedium);
5877 cableconnector->SetLineColor(fColorG10);
5878 // Strip Connection
5879 TGeoBBox* endcapstripconnectionshape =
5880 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5881 0.5*fgkEndCapStripConnectionThickness,
5882 0.5*fgkEndCapStripConnectionWidth);
5883 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5884 endcapstripconnectionshape,
5885 fSSDSupportRingAl);
5886 endcapstripconnection->SetLineColor(fColorAl);
5887 // Interface Card B
5888 const Int_t kcardBvertexnumber = 12;
5889 Double_t xcardBvertexnumber[kcardBvertexnumber];
5890 Double_t ycardBvertexnumber[kcardBvertexnumber];
5891
5892 xcardBvertexnumber[0] = 0.0;
5893 xcardBvertexnumber[1] = xcardBvertexnumber[0];
5894 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5895 xcardBvertexnumber[3] = xcardBvertexnumber[2];
5896 xcardBvertexnumber[4] = xcardBvertexnumber[1];
5897 xcardBvertexnumber[5] = xcardBvertexnumber[4];
5898 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5899 xcardBvertexnumber[7] = xcardBvertexnumber[6];
5900 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5901 xcardBvertexnumber[9] = xcardBvertexnumber[8];
5902 xcardBvertexnumber[10] = xcardBvertexnumber[7];
5903 xcardBvertexnumber[11] = xcardBvertexnumber[10];
5904
5905 ycardBvertexnumber[0] = 0.0;
5906 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
5907 ycardBvertexnumber[2] = ycardBvertexnumber[1];
5908 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5909 ycardBvertexnumber[4] = ycardBvertexnumber[3];
5910 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5911 ycardBvertexnumber[6] = ycardBvertexnumber[5];
5912 ycardBvertexnumber[7] = ycardBvertexnumber[4];
5913 ycardBvertexnumber[8] = ycardBvertexnumber[7];
5914 ycardBvertexnumber[9] = ycardBvertexnumber[1];
5915 ycardBvertexnumber[10] = ycardBvertexnumber[9];
5916 ycardBvertexnumber[11] = ycardBvertexnumber[0];
5917
5918 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5919 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5920 interfacecardBshape->DefineSection(0,0.);
5921 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5922 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5923 fSSDMountingBlockMedium);
5924 interfacecardB->SetLineColor(46);
5925 // Interface Card B Electronic Board
5926 const Int_t kelectboardcardBvertexnumber = 14;
5927 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5928 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5929
5930 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5931 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
5932 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
5933 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
5934 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
5935 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
5936 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
5937 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
5938 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
5939 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
5940 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
5941 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
5942 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
5943 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
5944
5945 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
5946 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
5947 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
5948 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
5949 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
5950 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
5951 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
5952 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
5953 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
5954 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
5955 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
5956 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
5957 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
5958 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
5959
5960 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
5961 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
5962 xelectboardcardBvertex,yelectboardcardBvertex);
5963 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
5964 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
5965 + fgkEndCapInterfaceElectBoardCardBThickness);
5966 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
5967 fSSDSupportRingAl);
5968 electboardcardB->SetLineColor(fColorAl);
5969 // Generating Stiffener 2
5970 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
5971 0.5*fgkEndCapStiffenerThickness,
5972 0.5*fgkEndCapStiffenerLength);
5973 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
5974 endcapstiffener->SetLineColor(fColorAl);
5975 // Generating Mother Interface Card B Container
5976 const Int_t kinterfacecardBmothervertexnumber = 10;
5977 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5978 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5979
5980 xinterfacecardBmothervertex[0] = 0.0;
5981 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
5982 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
5983 + fgkEndCapInterfaceCardBThickness;
5984 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
5985 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
5986 + fgkEndCapInterfaceElectBoardCardBThickness;
5987 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
5988 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
5989 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
5990 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
5991 + fgkEndCapCardJMDConnectorLength[0];
5992 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
5993
5994 yinterfacecardBmothervertex[0] = 0.0;
5995 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
5996 + fgkEndCapInterfaceCardBWidth[1]
5997 + fgkEndCapInterfaceCardBWidth[2];
5998 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
5999 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6000 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6001 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6002 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6003 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6004 + fgkEndCapCardJMDConnectorWidth[0]
6005 + fgkEndCapCardJMDConnectorWidth[1];
6006 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6007 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6008 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6009 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6010 xinterfacecardBmothervertex,
6011 yinterfacecardBmothervertex);
6012 interfacecardBmothershape->DefineSection(0,-1.e-15);
6013 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6014 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6015 interfacecardBmothershape,fSSDAir);
6016 electboardcardB->SetLineColor(fColorAl);
6017 // Positioning Volumes Mother Interface Card B Container
6018 TGeoRotation* interfacecardBrot = new TGeoRotation();
6019 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6020 interfacecardBrot->SetAngles(90.,-90.,-90.);
6021 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6022 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6023 TGeoRotation* electboardcardBrot = new TGeoRotation();
6024 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6025 electboardcardBrot->SetAngles(90.,90.,-90.);
6026 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6027 TGeoCombiTrans* electboardcardBcombitrans =
6028 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6029 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6030 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6031 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6032 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6033 TGeoTranslation* jmdconnectorcardBtrans[3];
6034 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6035 for(Int_t i=0; i<3; i++){
6036 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6037 + fgkEndCapCardJMDConnectorLength[0],
6038 fgkEndCapCardElectBoardLayerWidth[1],
6039 0.5*fgkEndCapCardJMDConnectorThickness
6040 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6041 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6042 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6043 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6044 *jmdconnectorcardBrot);
6045 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6046 }
6047 // Mother Supply Card Container
6048 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6049 // Interface Card Container
6050 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6051 // Placing Volumes in Mother Supply Card Container
6052 // JMD Connector Positioning
6053 TGeoTranslation* jmdconnectortrans[2];
6054 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6055 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6056 fgkEndCapCardElectBoardBackLength[0]
6057 - fgkEndCapCardJMDConnectorThickness
6058 - fgkEndCapCardJMDConnectorToLayer);
6059 TGeoRotation* jmdconnectorot = new TGeoRotation();
6060 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6061 + 2.*fgkEndCapCardJMDConnectorLength[0]
6062 + 2.*fgkEndCapCardElectBoardLayerThickness,
6063 fgkEndCapCardElectBoardLayerWidth[1],
6064 fgkEndCapCardJMDConnectorThickness
6065 + fgkEndCapCardJMDConnectorToLayer);
6066 jmdconnectorot->SetAngles(90.,180.,-90);
6067 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6068 * jmdconnectorot);
6069 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6070 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6071 // Top Cable Connector Placing
6072 TGeoRotation* cableconnectorot[2];
6073 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6074 TGeoTranslation* cableconnectortrans[3];
6075 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6076 cableconnectorot[0]->SetAngles(90.,0.,0.);
6077 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6078 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6079 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6080 *cableconnectorot[0]);
6081 TGeoHMatrix* cableconnectormatrix[2];
6082 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6083 new TGeoHMatrix((*cableconnectorot[1])
6084 *(*cableconnectorcombitrans));
6085 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6086 - fgkEndCapCardCableConnectorThickness,
6087 fgkEndCapCardCableConnectorLength[0]
6088 + fgkEndCapCardCableConnectorToLayer);
6089 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6090 - 2.*fgkEndCapCardCableConnectorThickness
6091 - fgkEndCapCardCableConnectorDistance,
6092 fgkEndCapCardCableConnectorLength[0]
6093 + fgkEndCapCardCableConnectorToLayer);
6094 for(Int_t i=0; i<2; i++){
6095 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6096 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6097 }
6098 TGeoRotation* electboardbackrot = new TGeoRotation();
6099 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6100 electboardbackrot->SetAngles(90.,-90.,-90.);
6101 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6102 + fgkEndCapCardJMDConnectorLength[0]
6103 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6104 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6105 *electboardbackrot);
6106 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6107 // Electronic Board Kapton Layer Positioning
6108 TGeoRotation* electlayerrot = new TGeoRotation();
6109 TGeoTranslation* electlayertrans[2];
6110 TGeoCombiTrans* electlayercombitrans[2];
6111 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6112 electlayerrot->SetAngles(90.,-90.,-90.);
6113 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6114 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6115 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6116 + 2.*fgkEndCapCardElectBoardLayerThickness
6117 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6118 for(Int_t i=0; i<2; i++){
6119 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6120 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6121 }
6122 // Placing Volumes in Mother Interface Card Container
6123 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6124 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6125 for(Int_t i=0; i<2; i++){
6126 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6127 }
6128 /////////////////////////////////////////////////////////////
6129 // Generation of Card Interface Container
6130 /////////////////////////////////////////////////////////////
6131 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6132 - fgkEndCapCardJMDConnectorLength[0]
6133 - fgkEndCapInterfaceCardBThickness
6134 - 9.*fgkEndCapStripConnectionThickness
6135 - 8.*fgkEndCapCardElectBoardBackThickness;
6136 const Int_t kcardinterfacecontainervertexnumber = 14;
6137 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6138 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6139 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6140 - 7.0*fgkEndCapStripConnectionThickness;
6141 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6142 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6143 + fgkEndCapStripConnectionThickness
6144 - fgkEndCapCardElectBoardLayerThickness
6145 - fgkEndCapCardCableConnectorWidth[0];
6146 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6147 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6148 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6149 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6150 + 2.0*fgkEndCapStripConnectionThickness;
6151 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6152 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6153 + fgkEndCapInterfaceCardBThickness;
6154 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6155 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6156 + fgkEndCapInterfaceElectBoardCardBThickness;
6157 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6158 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6159 - fgkEndCapInterfaceElectBoardCardBThickness
6160 + fgkEndCapCardJMDConnectorLength[0]
6161 + stiffenertransx+fgkEndCapStiffenerWidth;
6162 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6163
6164 ycardinterfacecontainervertex[0] = 0.;
6165 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6166 + fgkEndCapCardJMDConnectorWidth[0]
6167 + fgkEndCapCardJMDConnectorWidth[1];
6168 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6169 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6170 - fgkEndCapStripConnectionWidth;
6171 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6172 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6173 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6174 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6175 + fgkEndCapInterfaceCardBWidth[1]
6176 + fgkEndCapInterfaceCardBWidth[2];
6177 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6178 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6179 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6180 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6181 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6182 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6183
6184 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6185 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6186 xcardinterfacecontainervertex,
6187 ycardinterfacecontainervertex);
6188 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6189 - fgkEndCapCardElectBoardBackLength[0]));
6190 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6191 + fgkEndCapCardElectBoardBackLength[0]));
6192 TGeoVolume** cardinterfacecontainer;
6193 cardinterfacecontainer = new TGeoVolume*[4];
6194 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6195 interfacecardmothershape,fSSDAir);
6196 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6197 interfacecardmothershape,fSSDAir);
6198 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6199 interfacecardmothershape,fSSDAir);
6200 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6201 interfacecardmothershape,fSSDAir);
6202 /////////////////////////////////
6203 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6204 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6205 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6206 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6207 /////////////////////////////////
6208 TGeoRotation* endcapstripconnectionrot[2];
6209 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6210 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6211 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6212 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6213 * (*endcapstripconnectionrot[0]));
6214 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6215 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6216 -0.5*fgkEndCapCardElectBoardBackThickness,
6217 fgkEndCapCardElectBoardBackWidth[0]
6218 -endcapstripconnectionshape->GetDZ(),
6219 0.5*fgkEndCapCardElectBoardBackLength[0]);
6220 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6221 TGeoTranslation* cardinterfacetrans[9];
6222 TGeoHMatrix* cardinterfacematrix[9];
6223 for(Int_t i=0; i<7; i++){
6224 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6225 + fgkEndCapCardElectBoardBackThickness),
6226 0.0,0.0);
6227 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6228 * (*endcapstripconnectionmatrix));
6229 }
6230 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6231 + fgkEndCapCardElectBoardBackThickness),
6232 0.0,0.0);
6233 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6234 * (*endcapstripconnectionmatrix));
6235 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6236 + fgkEndCapCardElectBoardBackThickness),
6237 0.0,0.0);
6238 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6239 * (*endcapstripconnectionmatrix));
6240
6241 for(Int_t i=0; i<4; i++){
6242 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6243 cardinterfacematrix[7]);
6244 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6245 cardinterfacematrix[8]);
6246 }
6247 TGeoTranslation* mothersupplycardtrans =
6248 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6249 + 2.*fgkEndCapCardJMDConnectorLength[0]
6250 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6251 TGeoHMatrix* mothersupplycardmatrix[7];
6252 Int_t index[4] = {1,1,1,1};
6253 for(Int_t i=0; i<7; i++){
6254 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6255 * (*mothersupplycardtrans));
6256 for(Int_t j=0; j<4; j++){
6257 switch(j){
6258 case 0: //Layer5 EndCap Left Side
6259 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6260 cardinterfacematrix[i]);
6261 if(i!=0){
6262 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6263 mothersupplycardmatrix[i]);
6264 index[j]++;
6265
6266 }
6267 break;
6268 case 1: //Layer5 EndCap Rigth Side
6269 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6270 cardinterfacematrix[i]);
6271 if(i>0&&i<6){
6272 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6273 mothersupplycardmatrix[i]);
6274 index[j]++;
6275 }
6276 break;
6277 case 2: //Layer6 EndCap Left Side
6278 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6279 cardinterfacematrix[i]);
6280 if(i!=6){
6281 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6282 mothersupplycardmatrix[i]);
6283 index[j]++;
6284 }
6285 break;
6286 case 3: //Layer6 EndCap Right Side
6287 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6288 cardinterfacematrix[i]);
6289 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6290 mothersupplycardmatrix[i]);
6291 index[j]++;
6292 break;
6293 }
6294 }
6295 }
6296 // Positioning Interface
6297 TGeoTranslation* motherinterfacecardtrans =
6298 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6299 +0.5*fgkEndCapCardElectBoardBackThickness
6300 -fgkEndCapCardElectBoardLayerThickness
6301 +fgkEndCapStripConnectionThickness,0.,0.);
6302 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6303 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6304 // Positioning Interface Card B
6305 TGeoTranslation* interfacecardBmothertrans =
6306 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6307 + 2.*fgkEndCapStripConnectionThickness
6308 + fgkEndCapCardElectBoardBackThickness,0.,
6309 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6310 - fgkEndCapCardElectBoardBackLength[0]));
6311 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6312 interfacecardBmothertrans);
6313 // Positioning Stiffener
6314 TGeoTranslation* endcapstiffenertrans =
6315 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6316 + 2.0*fgkEndCapStripConnectionThickness
6317 + fgkEndCapInterfaceCardBThickness
6318 + fgkEndCapCardJMDConnectorLength[0]
6319 + stiffenertransx
6320 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6321 endcapstiffenershape->GetDZ()
6322 - 0.5*(fgkEndCapStiffenerLength
6323 - fgkEndCapCardElectBoardBackLength[0]));
6324 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6325 /////////////////////////////////////////////////////////////
6326 // Deallocating memory
6327 /////////////////////////////////////////////////////////////
6328 delete interfacecardBrot;
6329 delete interfacecardBtrans;
6330 delete electboardcardBtrans;
6331 delete electboardcardBrot;
6332 delete jmdconnectorcardBrot;
6333 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6334 delete jmdconnectorot;
6335 delete jmdconnectortrans[1];
6336 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6337 delete cableconnectorcombitrans;
6338 delete electboardbacktrans;
6339 delete electboardbackrot;
6340 delete electlayerrot;
6341 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6342 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6343 delete mothersupplycardtrans;
6344 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6345 /////////////////////////////////////////////////////////////
6346 return cardinterfacecontainer;
6347 }
6348 ////////////////////////////////////////////////////////////////////////////////
6349 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6350 /////////////////////////////////////////////////////////////
6351 // Method returning EndCap Mother Volume
6352 /////////////////////////////////////////////////////////////
6353 const Int_t kendcapcoverplatesmallholenumber = 9;
6354 Double_t endcapmotherorigin[3];
6355 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6356 + 0.5 *(fgkEndCapCoverPlateLength[3]
6357 + 2.0 * fgkEndCapCoverPlateLength[2]);
6358 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6359 - fgkEndCapCoverPlateWidth[2]
6360 - (kendcapcoverplatesmallholenumber-1)
6361 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6362 + 0.5*(fgkEndCapSideCoverLength[2]
6363 + fgkEndCapCoverPlateWidth[1]
6364 - fgkEndCapCoverPlateWidth[0])
6365 - (fgkEndCapCoverPlateWidth[1]
6366 - fgkEndCapCoverPlateWidth[0]);
6367 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6368 + 2.*fgkEndCapCoolingTubeRadiusMax
6369 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6370 + fgkEndCapSideCoverWidth[1]
6371 + fgkEndCapSideCoverThickness
6372 + fgkEndCapKaptonFoilThickness);
6373 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6374 + 2.0* fgkEndCapCoverPlateLength[2]
6375 + 2.0* fgkEndCapSideCoverThickness),
6376 0.5* (fgkEndCapSideCoverLength[2]
6377 + fgkEndCapCoverPlateWidth[1]
6378 - fgkEndCapCoverPlateWidth[0]),
6379 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6380 + fgkEndCapSideCoverWidth[1]
6381 + fgkEndCapSideCoverThickness
6382 + fgkEndCapKaptonFoilThickness),
6383 endcapmotherorigin);
6384 TGeoVolume** endcapassembly;
6385 endcapassembly = new TGeoVolume*[4];
6386 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6387 endcapmothershape,fSSDAir);
6388 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6389 endcapmothershape,fSSDAir);
6390 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6391 endcapmothershape,fSSDAir);
6392 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6393 endcapmothershape,fSSDAir);
6394 /////////////////////////////////
6395 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6396 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6397 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6398 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6399 /////////////////////////////////
6400 /////////////////////////////////////////////////////
6401 // Placing Endcap Cover Plate
6402 /////////////////////////////////////////////////////
6403 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6404 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6405 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6406 TGeoCombiTrans* endcapcoverplatecombitrans =
6407 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6408 endcapcoverplaterot);
6409 TGeoTranslation* endcapcoverplatetrans =
6410 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6411 TGeoHMatrix* endcapcoverplatematrix =
6412 new TGeoHMatrix((*endcapcoverplatetrans)
6413 * (*endcapcoverplatecombitrans));
6414 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6415 /////////////////////////////////////////////////////
6416 // Placing Endcap Side Cover
6417 /////////////////////////////////////////////////////
6418 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6419 TGeoRotation* endcapsidecoverot[2];
6420 TGeoCombiTrans* endcapsidecovercombitrans[3];
6421 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6422 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6423 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6424 - 0.5*(fgkEndCapCoverPlateWidth[0]
6425 - fgkEndCapCoverPlateWidth[2]
6426 - (kendcapcoverplatesmallholenumber-1)
6427 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6428 + 0.*fgkEndCapCoverPlateWidth[0]
6429 + fgkEndCapSideCoverLength[2],
6430 0.5*(fgkEndCapSideCoverThickness
6431 + fgkEndCapCoverPlateThickness)
6432 - 0.5*fgkEndCapCoverPlateThickness,
6433 endcapsidecoverot[0]);
6434 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6435 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6436 0.5*fgkEndCapCoverPlateThickness
6437 -fgkEndCapSideCoverWidth[1],
6438 endcapsidecoverot[1]);
6439 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6440 +fgkEndCapCoverPlateLength[3]
6441 +2.*fgkEndCapCoverPlateLength[2]
6442 +fgkEndCapSideCoverThickness,0.0,
6443 0.5*fgkEndCapCoverPlateThickness
6444 -fgkEndCapSideCoverWidth[1],
6445 endcapsidecoverot[1]);
6446 TGeoHMatrix* endcapsidecovermatrix[2];
6447 for(Int_t i=0; i<2; i++){
6448 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6449 * (*endcapsidecovercombitrans[0]));
6450 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6451 endcapsidecovermatrix[i]);
6452 }
6453 /////////////////////////////////////////////////////
6454 // Placing Endcap Cooling Tube
6455 /////////////////////////////////////////////////////
6456 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6457 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6458 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6459 TGeoCombiTrans* endcapccolingtubecombitrans
6460 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6461 + fgkEndCapCoolingTubeAxialRadius[1])
6462 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6463 - fgkEndCapCoolingTubeToCoverSide,
6464 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6465 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6466 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6467 endcapccolingtubecombitrans);
6468 /////////////////////////////////////////////////////
6469 // Placing Screws
6470 /////////////////////////////////////////////////////
6471 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6472 fgkEndCapCoverPlateScrewRadiusMin};
6473 Int_t screwcoverplatedgesnumber[2] = {20,20};
6474 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6475 fgkEndCapCoverPlateThickness
6476 + fgkEndCapCoolingTubeRadiusMax};
851c0ce3 6477 TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
9b0c60ab 6478 screwcoverplatedgesnumber,
6479 screwcoverplatesection);
6480 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6481 screwcoverplateshape,
6482 fSSDCoolingTubePhynox);
6483 screwcoverplate->SetLineColor(12);
6484 Double_t transx[4] = {0,
6485 fgkEndCapCoverPlateSmallHoleSeparation[0],
6486 fgkEndCapCoverPlateSmallHoleSeparation[0]
6487 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6488 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6489 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6490 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6491// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6492 TGeoTranslation*** endcapcoverplatescrewtrans;
6493 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6494 Int_t index = 0;
6495 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6496 endcapcoverplatescrewtrans[i] =
6497 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6498 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6499 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6500 if(index==1||index==9||index==28||index==36){
6501 endcapcoverplatescrewtrans[i][j] =
6502 new TGeoTranslation(transx[i],
6503 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6504 fgkEndCapSideCoverThickness);
6505 }
6506 else{
6507 endcapcoverplatescrewtrans[i][j] =
6508 new TGeoTranslation(transx[i],
6509 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6510 0.);
6511 }
6512 if(index!=19)
6513 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6514 endcapcoverplatescrewtrans[i][j]);
6515 }
6516 }
6517 /////////////////////////////////////////////////////
6518 // Placing Cover Plate Clips
6519 /////////////////////////////////////////////////////
6520 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6521 0.5*fgkEndCapCoverPlateClipWidth,
6522 0.5*fgkEndCapSideCoverThickness);
6523 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6524 endcapcoverplateclipshape,
6525 fSSDCoolingTubePhynox);
6526 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6527 0.5*fgkEndCapCoverPlateDownClipWidth,
6528 0.5*fgkEndCapSideCoverThickness);
6529 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6530 endcapcoverplatedownclipshape,
6531 fSSDCoolingTubePhynox);
6532 TGeoTranslation* endcapcoverplatecliptrans[4];
6533 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6534 - fgkEndCapCoverPlateLength[0]
6535 - fgkEndCapSideCoverThickness,
6536 0.0,
6537 0.5*(fgkEndCapSideCoverThickness
6538 + fgkEndCapCoverPlateThickness));
6539 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6540 - fgkEndCapCoverPlateLength[0]
6541 - fgkEndCapSideCoverThickness,
6542 (kendcapcoverplatescrewnumber[1]-1)
6543 * fgkEndCapSideCoverWidth[5],
6544 0.5*(fgkEndCapSideCoverThickness
6545 + fgkEndCapCoverPlateThickness));
6546 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6547 - fgkEndCapCoverPlateLength[0]
6548 + fgkEndCapCoverPlateLength[1]
6549 + 2.*fgkEndCapCoverPlateLength[0]
6550 - fgkEndCapCoverPlateClipLength
6551 + fgkEndCapSideCoverThickness,
6552 0.0,
6553 0.5*(fgkEndCapSideCoverThickness
6554 + fgkEndCapCoverPlateThickness));
6555 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6556 - fgkEndCapCoverPlateLength[0]
6557 + fgkEndCapCoverPlateLength[1]
6558 + 2.*fgkEndCapCoverPlateLength[0]
6559 - fgkEndCapCoverPlateClipLength
6560 + fgkEndCapSideCoverThickness,
6561 (kendcapcoverplatescrewnumber[1]-1)
6562 * fgkEndCapSideCoverWidth[5],
6563 0.5*(fgkEndCapSideCoverThickness
6564 + fgkEndCapCoverPlateThickness));
6565 endcapcoverplateclip->SetLineColor(fColorPhynox);
6566 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6567 for(Int_t i=0; i<4; i++)
6568 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6569 endcapcoverplatecliptrans[i]);
6570 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6571 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6572 - fgkEndCapCoverPlateLength[0]
6573 - fgkEndCapSideCoverThickness,
6574 0.5*(fgkEndCapCoverPlateDownClipWidth
6575 - fgkEndCapCoverPlateClipWidth),
6576 0.5*(fgkEndCapSideCoverThickness
6577 + fgkEndCapCoverPlateThickness)
6578 - fgkEndCapSideCoverWidth[1]
6579 - fgkEndCapSideCoverThickness);
6580 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6581 - fgkEndCapCoverPlateLength[0]
6582 - fgkEndCapSideCoverThickness,
6583 0.5*(fgkEndCapCoverPlateDownClipWidth
6584 - fgkEndCapCoverPlateClipWidth)
6585 + fgkEndCapSideCoverLength[2]
6586 - fgkEndCapCoverPlateDownClipWidth,
6587 0.5*(fgkEndCapSideCoverThickness
6588 + fgkEndCapCoverPlateThickness)
6589 - fgkEndCapSideCoverWidth[1]
6590 - fgkEndCapSideCoverThickness);
6591 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6592 - fgkEndCapCoverPlateLength[0]
6593 + fgkEndCapSideCoverThickness
6594 + fgkEndCapCoverPlateLength[1]
6595 + 2.0*fgkEndCapCoverPlateLength[0]
6596 - fgkEndCapCoverPlateDownClipLength,
6597 0.5*(fgkEndCapCoverPlateDownClipWidth
6598 - fgkEndCapCoverPlateClipWidth),
6599 0.5*(fgkEndCapSideCoverThickness
6600 + fgkEndCapCoverPlateThickness)
6601 - fgkEndCapSideCoverWidth[1]
6602 - fgkEndCapSideCoverThickness);
6603 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6604 - fgkEndCapCoverPlateLength[0]
6605 + fgkEndCapSideCoverThickness
6606 + fgkEndCapCoverPlateLength[1]
6607 + 2.0*fgkEndCapCoverPlateLength[0]
6608 - fgkEndCapCoverPlateDownClipLength,
6609 0.5*(fgkEndCapCoverPlateDownClipWidth
6610 - fgkEndCapCoverPlateClipWidth)
6611 + fgkEndCapSideCoverLength[2]
6612 - fgkEndCapCoverPlateDownClipWidth,
6613 0.5*(fgkEndCapSideCoverThickness
6614 + fgkEndCapCoverPlateThickness)
6615 - fgkEndCapSideCoverWidth[1]
6616 - fgkEndCapSideCoverThickness);
6617 for(Int_t i=0; i<4; i++)
6618 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6619 endcapcoverplatedowncliptrans[i]);
6620 /////////////////////////////////////////////////////
6621 // Placing Kapton Foil
6622 /////////////////////////////////////////////////////
6623 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6624 0.5*fgkEndCapKaptonFoilWidth,
6625 0.5*fgkEndCapKaptonFoilThickness);
6626 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6627 endcapkaptonfoilshape,
6628 fSSDKaptonFlexMedium);
6629 endcapkaptonfoil->SetLineColor(8);
6630 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6631 0.5*fgkEndCapKaptonFoilWidth
6632 - 0.5*fgkEndCapCoverPlateClipWidth,
6633 0.5*fgkEndCapCoverPlateThickness
6634 - 0.5*fgkEndCapKaptonFoilThickness
6635 - fgkEndCapSideCoverWidth[1]
6636 - fgkEndCapSideCoverThickness);
6637 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6638 /////////////////////////////////////////////////////////////
6639 // Placing Electronic Tubes
6640 /////////////////////////////////////////////////////////////
6641 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6642 - fgkEndCapInterfaceCardBThickness
6643 - 9.*fgkEndCapStripConnectionThickness
6644 - 8.*fgkEndCapCardElectBoardBackThickness,
6645 fgkEndCapKaptonFoilWidth
6646 - fgkEndCapInterfaceCardBThickness
6647 - 9.*fgkEndCapStripConnectionThickness
6648 - 8.*fgkEndCapCardElectBoardBackThickness
6649 - fgkEndCapInterfaceElectBoardCardBThickness};
6650 TGeoVolume* endcapeffectivecables[2];
6651 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6652 fgkEndCapEffectiveCableRadiusMax,
6653 endcapeffectivecableswidth[0],
6654 10,"EndCapEffectiveCables1");
6655 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6656 fgkEndCapEffectiveCableRadiusMax,
6657 endcapeffectivecableswidth[1],
6658 25,"EndCapEffectiveCables2");
6659 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6660 TGeoTranslation* endcapeffectivecablestrans[2];
6661 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6662 - 0.5*endcapeffectivecableswidth[0]
6663 - 0.5*(fgkEndCapCoverPlateWidth[0]
6664 - fgkEndCapCoverPlateWidth[2]
6665 - (kendcapcoverplatesmallholenumber-1)
6666 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6667 + fgkEndCapSideCoverLength[2],
6668 - 0.5*fgkEndCapCoverPlateThickness
6669 - (fgkEndCapCardElectBoardBackWidth[0]
6670 - fgkEndCapInterfaceCardBWidth[0]
6671 - fgkEndCapInterfaceCardBWidth[1]));
6672 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6673 - 0.5*endcapeffectivecableswidth[1]
6674 - 0.5*(fgkEndCapCoverPlateWidth[0]
6675 - fgkEndCapCoverPlateWidth[2]
6676 - (kendcapcoverplatesmallholenumber-1)
6677 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6678 + fgkEndCapSideCoverLength[2],
6679 - 0.5*fgkEndCapCoverPlateThickness
6680 - (fgkEndCapCardElectBoardBackWidth[0]
6681 - fgkEndCapInterfaceCardBWidth[0])
6682 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6683 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6684 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6685 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6686 *endcapeffectivecablesrot);
6687 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6688 *endcapeffectivecablesrot);
47f8de53 6689// for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6690// endcapeffectivecablescombitrans[0]);
9b0c60ab 6691 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6692 endcapeffectivecablescombitrans[1]);
6693 /////////////////////////////////////////////////////////////
6694 // Placing End Cap Cards
6695 /////////////////////////////////////////////////////////////
6696 TGeoVolume** endcapcards = GetEndCapCards();
6697 TGeoRotation* endcapcardsrot[2];
6698 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6699 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6700 TGeoTranslation* endcapcardstrans[2];
6701 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6702 - fgkEndCapCardElectBoardBackLength[0]));
6703 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6704 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6705 TGeoHMatrix* endcapcardsmatrix[2];
6706 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6707 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6708 - fgkEndCapCardJMDConnectorLength[0]
6709 - fgkEndCapInterfaceCardBThickness
6710 - 9.*fgkEndCapStripConnectionThickness
6711 - 8.*fgkEndCapCardElectBoardBackThickness;
6712 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6713 - fgkEndCapCoverPlateLength[0]
6714 + 0.5 * (fgkEndCapCoverPlateLength[3]
6715 + 2.0 * fgkEndCapCoverPlateLength[2]),
6716 - stiffenertransx-fgkEndCapStiffenerWidth
6717 - fgkEndCapCardJMDConnectorLength[0]
6718 - fgkEndCapInterfaceCardBThickness
6719 - 2.0 * fgkEndCapStripConnectionThickness
6720 - 1.5 * fgkEndCapInterfaceCardBThickness
6721 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6722 - fgkEndCapCoverPlateWidth[2]
6723 - (kendcapcoverplatesmallholenumber-1)
6724 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6725 + fgkEndCapKaptonFoilWidth,
6726 0.5*fgkEndCapCoverPlateThickness
6727 - fgkEndCapSideCoverWidth[1]);
6728 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6729 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6730 /////////////////////////////////////////////////////////////
6731 // Deallocating memory
6732 /////////////////////////////////////////////////////////////
6733 delete endcapcoverplaterot;
6734 delete endcapcoverplatecombitrans;
6735 delete endcapcoverplatetrans;
6736 for(Int_t i=0; i<3; i++){
6737 delete endcapsidecovercombitrans[i];
6738 if(i<2) delete endcapsidecoverot[i];
6739 }
6740 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6741 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6742 delete endcapcardsmatrix[0];
6743 return endcapassembly;
6744 }
6745 ////////////////////////////////////////////////////////////////////////////////
6746 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6747 Double_t radiusmax,
6748 Double_t width,
6749 Int_t ncables,
a6e0ebfe 6750 const char* volname){
9b0c60ab 6751 /////////////////////////////////////////////////////////////
6752 // Generating EndCap High Voltage Tubes
6753 /////////////////////////////////////////////////////////////
6754 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
60e55aee 6755 Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6756
9b0c60ab 6757 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6758 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6759 effectiveouteradius,0.5*width);
6760 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6761 effectiveinnertubeshape,
6762 fSSDStiffenerConnectorMedium);
6763 effectiveinnertube->SetLineColor(41);
6764 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6765 effectiveoutertubeshape,
6766 fSSDKaptonChipCableMedium);
6767 effectiveoutertube->SetLineColor(39);
6768 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6769 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6770 effectivemothertube->AddNode(effectiveinnertube,1);
6771 effectivemothertube->AddNode(effectiveoutertube,1);
6772 return effectivemothertube;
6773 }
6774 ////////////////////////////////////////////////////////////////////////////////
6775 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6776 /////////////////////////////////////////////////////////////
6777 // Generating EndCap Support Layer 5 and Layer 6
6778 /////////////////////////////////////////////////////////////
6779 const Int_t knedges = 5;
6780 ///////////////////////////////////////////////
6781 // Setting the vertices for TGeoXtru Up Volume
6782 ///////////////////////////////////////////////
6783 const Int_t klayernumber = 2;
6784 Double_t xupvertex[klayernumber][knedges+3];
6785 Double_t yupvertex[klayernumber][knedges+3];
6786 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6787 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6788 Double_t middlepsi[klayernumber] = {0.0,0.0};
6789 for(Int_t i=0; i<klayernumber; i++){
6790 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6791 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6792 xupvertex[i][2] = -xupvertex[i][1];
6793 xupvertex[i][3] = -xupvertex[i][0];
6794
6795 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6796 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6797 yupvertex[i][2] = yupvertex[i][1];
6798 yupvertex[i][3] = yupvertex[i][0];
6799
6800 middledgeangle[i] = upedgeangle[i]/knedges;
6801 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6802 for(Int_t j=1; j<knedges; j++){
6803 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6804 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6805 }
6806 }
6807 ////////////////////////////////////
6808 // Generating Up TGeoXtru
6809 ////////////////////////////////////
6810 TGeoXtru* upendcapsupportshape[klayernumber];
6811 TGeoVolume* upendcapsupport[klayernumber];
a3f8715e 6812 char upendcapsupportname[100];
9b0c60ab 6813 for(Int_t i=0; i<klayernumber; i++){
6814 upendcapsupportshape[i] = new TGeoXtru(2);
6815 sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6816 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6817 upendcapsupportshape[i]->DefineSection(0,0.);
6818 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6819 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 6820 fSSDSupportRingAl);
9b0c60ab 6821 upendcapsupport[i]->SetLineColor(5);
6822 }
6823 ///////////////////////////////////////////////
6824 // Setting the vertices for TGeoXtru Down Volume
6825 ///////////////////////////////////////////////
6826 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6827 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6828 for(Int_t i=0; i<klayernumber; i++){
6829 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6830 xdownvertex[i][1] = xupvertex[i][0];
6831 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6832 ydownvertex[i][1] = yupvertex[i][0];
6833 for(Int_t j=0; j<knedges; j++){
6834 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6835 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6836 }
6837 for(Int_t j=0; j<knedges; j++){
6838 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6839 * CosD(middlepsi[i]+j*middledgeangle[i]);
6840 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6841 * SinD(middlepsi[i]+j*middledgeangle[i]);
6842 }
6843 }
6844 ////////////////////////////////////
6845 // Generating Down TGeoXtru
6846 ////////////////////////////////////
6847 TGeoXtru* downendcapsupportshape[klayernumber];
6848 TGeoVolume* downendcapsupport[klayernumber];
a3f8715e 6849 char downendcapsupportname[100];
9b0c60ab 6850 for(Int_t i=0; i<klayernumber; i++){
6851 downendcapsupportshape[i] = new TGeoXtru(2);
6852 sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
6853 downendcapsupportshape[i] = new TGeoXtru(2);
6854 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6855 if(i==0){
6856 downendcapsupportshape[i]->DefineSection(0,0.);
6857 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6858 }
6859 else{
6860 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6861 - fgkEndCapSupportLowWidth[i]);
6862 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6863 }
6864 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 6865 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 6866 downendcapsupport[i]->SetLineColor(5);
6867 }
6868 ///////////////////////////////////////////////
6869 // Setting TGeoPgon Volume
6870 ///////////////////////////////////////////////
6871 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6872 fgkSSDLay6LadderNumber};
6873 TGeoPgon* endcapsupportmothershape[klayernumber];
6874 TGeoVolume** endcapsupportmother;
6875 endcapsupportmother = new TGeoVolume*[klayernumber];
a3f8715e 6876 char endcapsupportmothername[100];
9b0c60ab 6877 for(Int_t i=0; i<klayernumber; i++){
6878 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6879 sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
6880 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6881 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6882 ydownvertex[i][0],yupvertex[i][1]);
6883 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 6884 fSSDAir);
9b0c60ab 6885 }
6886 ////////////////////////////////////
6887 TGeoRotation** endcapsupportrot[klayernumber];
6888 for(Int_t i=0; i<2; i++){
6889 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6890 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6891 endcapsupportrot[i][j] = new TGeoRotation();
6892 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6893 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6894 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6895 }
6896 }
6897 return endcapsupportmother;
6898 }
6899 ////////////////////////////////////////////////////////////////////////////////
6900 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6901 /////////////////////////////////////////////////////////////
6902 // Setting End Cap Support Layer 5 and 6.
6903 /////////////////////////////////////////////////////////////
6904 const Int_t kendcapcoverplatesmallholenumber = 9;
6905 const Int_t klayernumber = 2;
6906 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6907 fgkSSDLay6LadderNumber};
6908 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6909 360.0/kssdlayladdernumber[1]};
6910 TGeoVolume** endcapsupport = EndCapSupport();
6911 TGeoVolume** endcapassembly = GetEndCapAssembly();
6912 TGeoPgon* endcapsupportshape[klayernumber];
6913 Double_t* radiusmin[klayernumber];
6914 Double_t* radiusmax[klayernumber];
6915 for(Int_t i=0; i<klayernumber; i++){
6916 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6917 radiusmin[i] = endcapsupportshape[i]->GetRmin();
6918 radiusmax[i] = endcapsupportshape[i]->GetRmax();
6919 }
6920 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6921 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6922 endcapassemblyshape->GetDY(),
6923 endcapassemblyshape->GetDZ()};
6924 ///////////////////////////////////////////////
6925 // Setting TGeoPgon Volume for Mother Container
6926 ///////////////////////////////////////////////
6927 TGeoPgon* endcapsupportsystemshape[klayernumber];
a3f8715e 6928 char endcapsupportsystemothername[100];
9b0c60ab 6929 for(Int_t i=0; i<klayernumber; i++){
6930 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6931 sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
6932 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
6933 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
6934 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6935 +2.*endcapassemblycenter[2])
6936 /CosD(0.5*upedgeangle[i]));
6937 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
6938 -(fgkEndCapCoverPlateWidth[1]
6939 - fgkEndCapCoverPlateWidth[0]),
6940 *radiusmin[i],
6941 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6942 +2.*endcapassemblycenter[2])
6943 /CosD(0.5*upedgeangle[i]));
6944 }
e5bf64ae 6945 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 6946 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
6947 endcapsupportsystemshape[0],fSSDAir);
6948 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
6949 endcapsupportsystemshape[0],fSSDAir);
6950 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
6951 endcapsupportsystemshape[1],fSSDAir);
6952 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
6953 endcapsupportsystemshape[1],fSSDAir);
6954 ///////////////////////////////////////////////
6955 TGeoTranslation* endcapassemblytrans[klayernumber];
6956 for(Int_t i=0; i<klayernumber; i++)
6957 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
6958 - fgkEndCapSideCoverThickness
6959 + endcapassemblycenter[0],
6960 - 0.5*fgkEndCapCoverPlateThickness
6961 - 2.0*fgkEndCapCoolingTubeRadiusMax
6962 + 2.0*endcapassemblycenter[2]
6963 + 0.5*fgkEndCapSupportLength[i]
6964 / TanD(0.5*upedgeangle[i]),
6965 0.5*(fgkEndCapCoverPlateWidth[0]
6966 - fgkEndCapCoverPlateWidth[2]
6967 - (kendcapcoverplatesmallholenumber-1)
6968 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
6969 TGeoRotation** endcapassemblyrot[klayernumber];
6970 TGeoHMatrix** endcapassemblymatrix[klayernumber];
6971 for(Int_t i=0; i<klayernumber; i++){
6972 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
6973 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
6974 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
6975 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
6976 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
6977 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
6978 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
6979 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6980 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
6981 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
6982 }
6983 }
6984 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
6985 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
6986 for(Int_t i=0; i<2*klayernumber; i++){
6987 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
6988 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
6989 endcapassemblymatrix[1][j+2]);
6990 }
6991 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
6992 }
6993 /////////////////////////////////////////////////////////////
6994 // Deallocating memory
6995 /////////////////////////////////////////////////////////////
6996 for(Int_t i=0; i<klayernumber; i++){
6997 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
6998 delete endcapassemblyrot[i][j];
6999 }
7b208ef4 7000 delete [] endcapassemblyrot[i];
9b0c60ab 7001 delete endcapassemblymatrix[i][0];
7002 delete endcapassemblymatrix[i][1];
7003 }
7004 /////////////////////////////////////////////////////////////
7005 }
7006 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7007 /////////////////////////////////////////////////////////////
7008 // Setting End Cap Support + End Cap Assembly of Layer 5.
7009 /////////////////////////////////////////////////////////////
7010 if (! moth) {
160835d5 7011 AliError("Can't insert end cap support of layer5, mother is null!\n");
9b0c60ab 7012 return;
7013 };
e5bf64ae 7014 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7015 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7016 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7017 fgkEndCapSupportCenterLay5ITSPosition
7018 + fgkEndCapSupportCenterLay5Position
7019 - fgkEndCapSideCoverLength[2]);
7020 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7021 fgkEndCapSideCoverLength[2]
7022 - fgkEndCapSupportCenterLay5Position
7023 - fgkEndCapSupportCenterLay5ITSPosition);
7024 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7025 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7026 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7027 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7028 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7029 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7030 /////////////////////////////////////////////////////////////
7031 // Deallocating memory
7032 /////////////////////////////////////////////////////////////
7033 delete endcapsupportsystemrot;
7034 delete endcapsupportsystemITSCentertrans[1];
7035 }
7036 /////////////////////////////////////////////////////////////
7037 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7038 /////////////////////////////////////////////////////////////
7039 // Setting End Cap Support + End Cap Assembly of Layer 6.
7040 /////////////////////////////////////////////////////////////
7041 if (! moth) {
160835d5 7042 AliError("Can't insert end cap support of layer6, mother is null!\n");
9b0c60ab 7043 return;
7044 };
e5bf64ae 7045 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7046 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7047 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7048 fgkEndCapSupportCenterLay6ITSPosition
7049 + fgkEndCapSupportCenterLay6Position
7050 - fgkEndCapSideCoverLength[2]);
7051 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7052 fgkEndCapSideCoverLength[2]
7053 - fgkEndCapSupportCenterLay6Position
7054 - fgkEndCapSupportCenterLay6ITSPosition);
7055 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7056 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7057 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7058 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7059 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7060 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7061 /////////////////////////////////////////////////////////////
7062 // Deallocating memory
7063 /////////////////////////////////////////////////////////////
7064 delete endcapsupportsystemrot;
7065 delete endcapsupportsystemITSCentertrans[1];
7066 }
7067 ////////////////////////////////////////////////////////////////////////////////
7068 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7069 /////////////////////////////////////////////////////////////
7070 // Setting Ladder Support of Layer 5.
7071 /////////////////////////////////////////////////////////////
7072 if (! moth) {
160835d5 7073 AliError("Can't insert ladder lupport of layer5, mother is null!\n");
9b0c60ab 7074 return;
7075 };
7076 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7077 fMotherVol = moth;
7078 TGeoTranslation* centerITSRingSupportLay5trans[2];
7079 for(Int_t i=0; i<2; i++){
7080 centerITSRingSupportLay5trans[i] =
7081 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7082 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7083 }
7084 }
7085 ////////////////////////////////////////////////////////////////////////////////
7086 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7087 /////////////////////////////////////////////////////////////
7088 // Setting Ladder Support of Layer 6.
7089 /////////////////////////////////////////////////////////////
7090 if (! moth) {
160835d5 7091 AliError("Can't insert ladder lupport of layer6, mother is null!\n");
9b0c60ab 7092 return;
7093 };
7094 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7095 fMotherVol = moth;
7096 TGeoTranslation* centerITSRingSupportLay6trans[2];
7097 for(Int_t i=0; i<2; i++){
7098 centerITSRingSupportLay6trans[i] =
7099 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7100 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7101 }
7102 }
7103 ////////////////////////////////////////////////////////////////////////////////
47f8de53 7104 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7105 /////////////////////////////////////////////////////////////
7106 // Setting Ladder Support of Layer 6.
7107 /////////////////////////////////////////////////////////////
7108 if (! moth) {
160835d5 7109 AliError("Can't insert SSD Cone, mother is null!\n");
47f8de53 7110 return;
7111 };
7112 if(!fSSDCone) SetSSDCone();
7113 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7114 + fgkSSDCentralAL3SupportLength);
7115 moth->AddNode(fSSDCone,1,ssdconetrans);
7116}
7117 ////////////////////////////////////////////////////////////////////////////////
7118 void AliITSv11GeometrySSD::SetSSDCone(){
7119 /////////////////////////////////////////////////////////////
7120 // Method generating SSDCone
7121 /////////////////////////////////////////////////////////////
7122 if(!fCreateMaterials) CreateMaterials();
7123 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7124 Double_t ssdpconesectionradiusmax[16];
7125 Double_t ssdpconesectionradiusmin[16];
7126 Double_t ssdpconezsection[16];
7127 TGeoPcon* ssdpconelittleholeshape[8];
7128 TGeoVolume* ssdpconelittlehole[8];
7129 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7130 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7131 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7132 / SinD(fgkSSDPConeAngle)
7133 + ssdpconesectionradiusmin[0];
7134 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7135 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7136 / SinD(fgkSSDPConeAngle);
7137 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7138 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7139 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7140 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7141 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7142 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7143 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7144 ssdpconelittlehole[0]->SetLineColor(4);
7145 /////////////////////////////////////////////////////////////
7146 ssdpconezsection[2] = ssdpconezsection[1];
7147 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7148 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7149 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7150 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7151 / SinD(fgkSSDPConeAngle);
7152 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7153 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7154 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7155 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7156 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7157 * TMath::RadToDeg();
7158 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7159 60.-ssdpconelittleholeangle,2);
7160 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7161 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7162 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7163 ssdpconelittlehole[1]->SetLineColor(4);
7164 TGeoRotation* ssdconelittleholerot[6];
7165 for(Int_t i=0; i<6; i++){
7166 ssdconelittleholerot[i] = new TGeoRotation();
7167 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7168 }
7169 /////////////////////////////////////////////////////////////
7170 ssdpconezsection[4] = ssdpconezsection[3];
7171 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7172 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7173 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7174 * CosD(fgkSSDPConeAngle)
7175 / SinD(fgkSSDPConeAngle);
7176 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7177 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7178 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7179 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7180 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7181 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7182 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7183 ssdpconelittlehole[2]->SetLineColor(4);
7184 ///////////////////////////////////////////////////
7185 ssdpconezsection[6] = ssdpconezsection[5];
7186 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7187 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7188 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7189 -ssdpconezsection[0]
7190 * CosD(fgkSSDPConeAngle)
7191 / SinD(fgkSSDPConeAngle);
7192 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7193 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7194 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7195 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7196 * TMath::RadToDeg();
7197 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7198 45.-ssdpconemiddleholeangle,2);
7199 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7200 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7201 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7202 ssdpconelittlehole[3]->SetLineColor(4);
7203 TGeoRotation* ssdconemiddleholerot[8];
7204 for(Int_t i=0; i<8; i++){
7205 ssdconemiddleholerot[i] = new TGeoRotation();
7206 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7207 }
7208 /////////////////////////////////////////////////////////////
7209 ssdpconezsection[8] = ssdpconezsection[7];
7210 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7211 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7212 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7213 * CosD(fgkSSDPConeAngle)
7214 / SinD(fgkSSDPConeAngle);
7215 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7216 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7217 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7218 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7219 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7220 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7221 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7222 ssdpconelittlehole[4]->SetLineColor(4);
7223 /////////////////////////////////////////////////////////////
7224 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7225 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7226 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7227 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7228 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7229 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7230 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7231 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7232 * TMath::RadToDeg();
7233 ssdpconezsection[10] = ssdpconezsection[9];
7234 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7235 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7236 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7237 * CosD(fgkSSDPConeAngle)
7238 / SinD(fgkSSDPConeAngle);
7239 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7240 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7241 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7242 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7243 ssdpconetrapezoidsectionangle,2);
7244 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7245 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7246 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7247 ssdpconelittlehole[5]->SetLineColor(4);
7248 TGeoRotation* ssdconeupradiusrot[8];
7249 for(Int_t i=0; i<8; i++){
7250 ssdconeupradiusrot[i] = new TGeoRotation();
7251 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7252 }
7253 /////////////////////////////////////////////////////////////
7254 ssdpconezsection[12] = ssdpconezsection[11];
7255 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7256 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7257 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7258 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7259 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7260 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7261 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7262 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7263 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7264 ssdpconelittlehole[6]->SetLineColor(4);
7265 /////////////////////////////////////////////////////////////
7266 ssdpconezsection[14] = 0.0;
7267 ssdpconezsection[15] = ssdpconezsection[0];
7268 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7269 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7270 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7271 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7272 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7273 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7274 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7275 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7276 ssdpconelittlehole[7]->SetLineColor(4);
7277 /////////////////////////////////////////////////////////////
7278 TGeoTube* ssdtubeconeshape[2];
7279 TGeoVolume* ssdtubecone[2];
7280 TGeoTranslation* ssdtubeconetrans[2];
7281 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7282 fgkSSDPConeExternalRadius,
7283 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7284 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7285 0.5*ssdpconezsection[0]);
7286 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7287 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7288 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7289 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7290 + ssdpconezsection[13]);
7291 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7292 ssdtubecone[0]->SetLineColor(4);
7293 ssdtubecone[1]->SetLineColor(4);
7294 /////////////////////////////////////////////////////////////
7295 // Mother Volume Container
7296 /////////////////////////////////////////////////////////////
7297 Double_t ssdconemotherradiusmin[8];
7298 Double_t ssdconemotherradiusmax[8];
7299 Double_t ssdconemothersection[8];
7300 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7301 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7302 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7303 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7304 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7305 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7306 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7307 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7308 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7309 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7310 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7311 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7312 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7313 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7314 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7315 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7316 ssdconemothersection[0] = 0.0;
7317 ssdconemothersection[1] = ssdpconezsection[0];
7318 ssdconemothersection[2] = ssdpconezsection[0];
7319 ssdconemothersection[3] = ssdpconezsection[11];
7320 ssdconemothersection[4] = ssdpconezsection[11];
7321 ssdconemothersection[5] = ssdpconezsection[13];
7322 ssdconemothersection[6] = ssdpconezsection[13];
7323 ssdconemothersection[7] = fgkSSDPConeLength;
7324 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7325 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7326 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7327 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7328 /////////////////////////////////////////////////////////////
7329 //Placing the Volumes into Mother
7330 /////////////////////////////////////////////////////////////
7331 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7332 for(Int_t i=0; i<6; i++){
7333 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7334 }
7335 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7336 for(Int_t i=0; i<8; i++){
7337 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7338 }
7339 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7340 for(Int_t i=0; i<8; i++){
7341 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7342 }
7343 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7344 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7345 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7346 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7347 /////////////////////////////////////////////////////////////
7348 // ITS General Support
7349 /////////////////////////////////////////////////////////////
7350 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7351 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7352 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7353 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7354 - fgkSSDCentralAL3SupportLength);
7355 ssdcentralsupport->SetLineColor(4);
7356 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7357 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7358 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7359 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7360 TGeoTranslation* ssdcentralal3supportrans[3];
7361 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7362 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7363 - 1.25*fgkSSDCentralAL3SupportLength);
7364 ssdcentralal3support->SetLineColor(4);
7365 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7366 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7367 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7368 Double_t ssdpconcentralradiusmin[2];
7369 Double_t ssdpconcentralradiusmax[2];
7370 Double_t ssdpconcentralsection[2];
7371 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7372 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7373 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7374 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7375 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7376 ssdpconcentralsection[1] = 0.;
7377 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7378 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7379 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7380 ssdpconcentralal3->SetLineColor(4);
7381 fSSDCone->AddNode(ssdpconcentralal3,1);
7382 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7383 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7384 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7385 -2.*fgkSSDCentralAL3SupportLength);
7386 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7387 *ssdcentralal3supportrot);
7388 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7389 TGeoRotation* ssdconemotherot = new TGeoRotation();
7390 ssdconemotherot->SetAngles(90.,180.,-90.);
7391 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7392 -2.*fgkSSDCentralAL3SupportLength);
7393 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7394 fSSDCone->AddNode(ssdconemother,1);
7395 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7396 /////////////////////////////////////////////////////////////
7397 // Deallocating memory
7398 /////////////////////////////////////////////////////////////
7399 delete ssdcentralal3supportrot;
7400 delete ssdcentralal3supportrans[2];
7401 delete ssdconemotherot;
7402 delete ssdconemothertrans;
7403 /////////////////////////////////////////////////////////////
7404 }
fcfbdd23 7405 ////////////////////////////////////////////////////////////////////////////////
7406 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7407 /////////////////////////////////////////////////////////////
7408 // Setting SSD Cables
7409 /////////////////////////////////////////////////////////////
7410 if (! moth) {
160835d5 7411 AliError("Can't insert SSD Cables, mother is null!\n");
fcfbdd23 7412 return;
7413 };
7414 TGeoVolume* ssdcables = SetSSDCables();
7415 moth->AddNode(ssdcables,1);
7416}
47f8de53 7417 ////////////////////////////////////////////////////////////////////////////////
7418 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7419 /////////////////////////////////////////////////////////////
7420 // Method generating SSDCables
7421 /////////////////////////////////////////////////////////////
7422 // SSD Layer 5 Cables
7423 //////////////////////////////////////////////////////////////////////////////////////////////////
7424 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7425 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
fcfbdd23 7426 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
47f8de53 7427 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7428 //////////////////////////////////////////////////////////////////////////////////////////////////
7429 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+fgkSSDCablesLay5TubeRadiusMin;
7430 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7431 - fgkSSDLowerPConeRadius)
7432 * TanD(fgkSSDPConeAngle);
7433 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7434 + fgkEndCapSupportCenterLay5Position
7435 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7436 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7437 - ssdcableslay5startconedistance;
7438 ssdcablelay5rightsidelength *= ssdcablesfactor;
7439 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+fgkSSDCablesLay5RightSideHeight;
7440 TGeoTube* ssdcablelay5rightubeshape = new TGeoTube(ssdcableslay5rigthsideradiusmin,
7441 ssdcableslay5rightsideradiusmax,
7442 0.5*ssdcablelay5rightsidelength);
7443 TGeoVolume* ssdcablelay5righttube = new TGeoVolume("SSDCableLay5RightSideTube",
7444 ssdcablelay5rightubeshape,
7445 fSSDCopper);
7446 ssdcablelay5righttube->SetLineColor(9);
7447 TGeoTranslation* ssdcablelay5rightrans =
7448 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7449 + fgkEndCapSupportCenterLay5Position
7450 + 0.5*ssdcablelay5rightsidelength);
7451 ////////////////////////////////////
7452 // Double_t cablescapacity[20];
7453 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7454 ////////////////////////////////////
7455 ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7456 ////////////////////////////////////
7457 // TGeoPCone Volumes
7458 ///////////////////////////////////
7459 TGeoPcon* ssdcableslay5pconshape[3];
7460 TGeoVolume* ssdcableslay5pcon[3];
7461 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7462 Double_t ssdcableslay5pconzsection[6];
7463 Double_t ssdcableslay5pconrmin[6];
7464 Double_t ssdcableslay5pconrmax[6];
7465 ssdcableslay5pconrmin[0] = ssdcablelay5rightubeshape->GetRmin();
7466 ssdcableslay5pconrmax[0] = ssdcablelay5rightubeshape->GetRmax();
7467 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7468 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+fgkSSDCablesLay5RightSideHeight;
7469 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7470 + fgkEndCapSupportCenterLay5Position
7471 + 2.*ssdcablelay5rightubeshape->GetDz();
7472 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7473 + fgkSSDCentralAL3SupportLength
7474 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7475 * TanD(fgkSSDPConeAngle);
7476 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7477 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7478 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7479 ssdcableslay5pconshape[0],fSSDCopper);
7480 ssdcableslay5pcon[0]->SetLineColor(9);
7481 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7482////////////////////////////////////
7483// cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7484////////////////////////////////////
7485 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7486 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7487 + fgkSSDCentralAL3SupportLength
7488 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7489 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7490 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7491 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7492 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7493 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7494 ssdcableangle,2);
7495 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7496 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7497 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7498 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7499 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7500 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3]+fgkSSDCablesLay5RightSideHeight;
7501 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7502 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7503 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7504 ssdcableslay5pcon[1]->SetLineColor(9);
7505 ////////////////////////////////////
7506 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7507 ssdcableangle,2);
7508 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7509 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7510 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7511 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7512 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7513 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7514 * TanD(fgkSSDPConeAngle)
7515 + 0.5*fgkSSDCentralSupportLength
7516 + fgkSSDCentralAL3SupportLength;
7517 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7518 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7519 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7520 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7521 ssdcableslay5pcon[2]->SetLineColor(9);
7522////////////////////////////////////
7523 TGeoRotation* ssdcableslay5pconrot[4];
7524 for(Int_t i=0; i<4; i++){
7525 ssdcableslay5pconrot[i] = new TGeoRotation();
7526 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7527 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7528 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
7529 }
7530 ////////////////////////////////////
7531 //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7532 //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7533 ////////////////////////////////////
7534 // Positioning Left SSD Cables Part
7535 ////////////////////////////////////
7536 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7537 - 0.5*ssdcablelay5rightsidelength
7538 - fgkEndCapSupportCenterLay5Position
7539 - fgkEndCapSupportCenterLay5ITSPosition);
7540 ssdcablesmother->AddNode(ssdcablelay5righttube,2,ssdcablesLay5RightTubeToLeftrans);
7541 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7542 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7543 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7544 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7545 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7546 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7547 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7548 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7549 }
7550 ////////////////////////////////////
7551 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7552 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7553 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7554 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7555 /////////////////////////////////////////////////////////////
7556 // Water Tubes Layer 5
7557 /////////////////////////
7558 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7559 ssdcableslay5rightsideradiusmax
7560 + fgkSSDCablesLay5RightSideWaterHeight,
7561 0.5*ssdcablelay5rightsidelength);
7562 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7563 ssdcablelay5rightubewatershape,
7564 fSSDCoolingTubeWater);
7565 ssdcablelay5rightwatertube->SetLineColor(7);
7566 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7567 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7568 ////////////////////////////////////
7569 // TGeoPCone Water Volumes Layer
7570 ///////////////////////////////////
7571 TGeoPcon* ssdcableslay5pconwatershape[3];
7572 TGeoVolume* ssdcableslay5pconwater[3];
7573 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7574 Double_t ssdcableslay5pconwaterzsection[6];
7575 Double_t ssdcableslay5pcwateronrmin[6];
7576 Double_t ssdcableslay5pconwaterrmax[6];
7577 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7578 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7579 + fgkSSDCablesLay5RightSideWaterHeight;
7580 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7581 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7582 + fgkSSDCablesLay5RightSideWaterHeight;
7583 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7584 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7585 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7586 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7587 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7588 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7589 ssdcableslay5pconwater[0]->SetLineColor(7);
7590 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7591 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7592////////////////////////////////////
7593 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7594 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7595 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7596 ssdcableangle,2);
7597 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7598 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7599 + fgkSSDCablesLay5RightSideWaterHeight;
7600 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7601 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7602 + fgkSSDCablesLay5RightSideWaterHeight;
7603 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7604 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7605 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7606 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7607 ssdcableslay5pconwater[1]->SetLineColor(7);
7608////////////////////////////////////
7609 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7610 ssdcableangle,2);
7611 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7612 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7613 + fgkSSDCablesLay5RightSideWaterHeight;
7614 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7615 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7616 + fgkSSDCablesLay5RightSideWaterHeight;
7617 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7618 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7619 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7620 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7621 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7622 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7623 ssdcableslay5pconwater[2]->SetLineColor(7);
7624////////////////////////////////////
7625 TGeoRotation* ssdcableslay5pconwaterot[4];
7626 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7627 for(Int_t i=0; i<4; i++){
7628 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7629 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7630 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7631 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7632 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7633 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7634 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7635 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7636 }
7637 /////////////////////////
7638 // SSD Layer 6 Cables
7639 /////////////////////////
7640 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+fgkSSDCablesLay6TubeRadiusMin;
7641 Double_t ssdcablelay6rightsidelength = 2.*ssdcablelay5rightsidelength;
7642 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+fgkSSDCablesLay6RightSideHeight;
7643 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7644 ssdcableslay6rightsideradiusmax,
7645 0.5*ssdcablelay6rightsidelength);
7646 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7647 ssdcablelay6rightubeshape,
7648 fSSDCopper);
7649 ssdcablelay6righttube->SetLineColor(9);
7650 TGeoTranslation* ssdcablelay6rightrans =
7651 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7652 + fgkEndCapSupportCenterLay6Position
7653 + 0.5*ssdcablelay6rightsidelength);
7654 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7655 - 0.5*ssdcablelay6rightsidelength
7656 - fgkEndCapSupportCenterLay6Position
7657 - fgkEndCapSupportCenterLay6ITSPosition);
7658 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7659 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7660 ////////////////////////////////////
7661 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7662 ////////////////////////////////////
7663 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7664 ssdcableangle,2);
7665 TGeoVolume* ssdcableslay6pcon;
7666 Double_t ssdcableslay6pconrmin[2];
7667 Double_t ssdcableslay6pconrmax[2];
7668 Double_t ssdcableslay6pconzsection[2];
7669 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7670 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7671 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7672 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7673 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7674 + fgkEndCapSupportCenterLay6Position
7675 + ssdcablelay6rightsidelength;
7676 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7677 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7678 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7679 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7680 ssdcableslay6pconshape,fSSDCopper);
7681 ssdcableslay6pcon->SetLineColor(9);
7682 for(Int_t i=0; i<4; i++){
7683 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7684 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7685 }
7686 ////////////////////////////////////
7687 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7688 /////////////////////////
7689 // Water Tubes Layer 6
7690 /////////////////////////
7691 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7692 ssdcableslay6rightsideradiusmax
7693 + fgkSSDCablesLay5RightSideWaterHeight,
7694 0.5*ssdcablelay6rightsidelength);
7695 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7696 ssdcablelay6righwatertubeshape,
7697 fSSDCoolingTubeWater);
7698 ssdcablelay6rightwatertube->SetLineColor(7);
7699 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7700 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7701 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7702 ssdcableangle,2);
7703 TGeoVolume* ssdcableslay6waterpcon;
7704 Double_t ssdcableslay6waterpconrmin[2];
7705 Double_t ssdcableslay6waterpconrmax[2];
7706 Double_t ssdcableslay6waterpconzsection[2];
7707 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7708 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7709 + fgkSSDCablesLay5RightSideWaterHeight;
7710 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7711 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7712 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7713 + fgkEndCapSupportCenterLay6Position
7714 + ssdcablelay6rightsidelength;
7715 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7716 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7717 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7718 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7719 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7720 ssdcableslay6waterpcon->SetLineColor(7);
7721 TGeoRotation* ssdcableslay6pconwaterot[4];
7722 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7723 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7724 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7725 for(Int_t i=0; i<4; i++){
7726 ssdcableslay6pconwaterot[i] = new TGeoRotation();
7727 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7728 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7729 * (*ssdcableslay6pconwaterot[i]));
7730 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7731 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7732 }
7733 ////////////////////////////////////////
7734 // From ITS Ring to Patch Panel3-RB26
7735 ////////////////////////////////////////
7736 Double_t ssdcablepatchpanel3BB26radiusmin[2];
7737 Double_t ssdcablepatchpanel3BB26radiusmax[2];
7738 Double_t ssdcablepatchpanel3RB26zsection[2];
cd2243fb 7739 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8;
47f8de53 7740 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
7741 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7742 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7743 ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
7744 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
7745 + 0.*fgkSSDCablesLay5RightSideHeight
cd2243fb 7746 + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7747 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
7748 + fgkSSDCentralAL3SupportLength
7749 + fgkSSDPConeZLength[0];
7750 ssdcablepatchpanel3RB26zsection[1] = fgkSSDPatchPanel2RB26ITSDistance;
7751 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
7752 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7753 - 0.5*ssdcableangle,ssdcableangle,2);
7754 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7755 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7756 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7757 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7758 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
7759 TGeoRotation* ssdcablepatchpanel3B26rot[3];
7760 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
67446e8a 7761 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
47f8de53 7762 ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
67446e8a 7763 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7764 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
47f8de53 7765 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0]
67446e8a 7766 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
47f8de53 7767 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
7768 ////////////////////////////////////
7769 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7770 ////////////////////////////////////////
7771 // ITS Ring Cables RB26 Part
7772 ////////////////////////////////////////
7773 Double_t ssdcableitsring3BB26pconzsection[2];
7774 Double_t ssdcableitsring3BB26pconrmin[2];
7775 Double_t ssdcableitsring3BB26pconrmax[2];
7776 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7777 + fgkSSDCentralAL3SupportLength
7778 + (4.0/5.0)*fgkSSDPConeZLength[0];
7779 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
cd2243fb 7780 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
47f8de53 7781 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
7782 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7783 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7784 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7785 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7786 TGeoPcon* ssdcableitsring3BB26pconshape[4];
7787 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7788 - 0.5*ssdcableangle,ssdcableangle
7789 + (fgkSSDCablesPatchPanel2RB26Angle[0]
7790 - fgkSSDCableAngle),2);
7791 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7792 - 0.5*ssdcableangle,ssdcableangle
7793 + 3.0*fgkSSDCableAngle
7794 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7795 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-fgkSSDCablesPatchPanel2RB26Angle[0]
7796 - 0.5*ssdcableangle,ssdcableangle
7797 - fgkSSDCableAngle
7798 + fgkSSDCablesPatchPanel2RB26Angle[0],2);
7799 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7800 - 0.5*ssdcableangle,ssdcableangle
7801 + 3.0*fgkSSDCableAngle
7802 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7803 for(Int_t i=0;i<4;i++)
7804 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7805 ssdcableitsring3BB26pconrmin[j],
7806 ssdcableitsring3BB26pconrmax[j]);
7807 TGeoVolume* ssdcableitsring3BB26pcon[4];
7808 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7809 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7810 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7811 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7812 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7813 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7814 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7815 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7816 for(Int_t i=0;i<4;i++){
7817 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
5ef8864c 7818 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
47f8de53 7819}
7820 ////////////////////////////////////
7821 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7822 // + ssdcableitsring3BB26pconshape[1]->Capacity()
7823 // + ssdcableitsring3BB26pconshape[2]->Capacity()
7824 // + ssdcableitsring3BB26pconshape[3]->Capacity();
7825 ////////////////////////////////////////
7826 // From ITS Ring to Patch Panel2-RB24
7827 ////////////////////////////////////////
7828 Double_t ssdcablepatchpanel3BB24radiusmin[2];
7829 Double_t ssdcablepatchpanel3BB24radiusmax[2];
7830 Double_t ssdcablepatchpanel3RB24zsection[2];
7831 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7832 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
7833 ssdcablepatchpanel3BB24radiusmin[1] = fgkSSDPatchPanel2RB24Radius;
7834 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
7835 + 0.*fgkSSDCablesLay5RightSideHeight
7836 + 0.*fgkSSDCablesLay6RightSideHeight
cd2243fb 7837 + 0.5*fgkSSDPatchPanelHeight;
47f8de53 7838 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7839 - fgkSSDCentralAL3SupportLength
7840 - fgkSSDPConeZLength[0];
7841 ssdcablepatchpanel3RB24zsection[1] = -fgkSSDPatchPanel2RB24ITSDistance;
7842 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
7843 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7844 - 0.5*ssdcableangle,ssdcableangle,2);
7845 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7846 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7847 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7848 ssdcablepatchpanel3RB24pconshape,
7849 fSSDCopper);
7850 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
7851 TGeoRotation* ssdcablepatchpanel3B24rot[3];
7852 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
67446e8a 7853 ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
47f8de53 7854 ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0]
7855 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
67446e8a 7856 ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
47f8de53 7857 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0]
7858 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7859 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
7860 ////////////////////////////////////
7861 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7862 ////////////////////////////////////////
7863 // ITS Ring Cables RB24 Part
7864 ////////////////////////////////////////
7865 Double_t ssdcableitsring3BB24pconzsection[2];
7866 Double_t ssdcableitsring3BB24pconrmin[2];
7867 Double_t ssdcableitsring3BB24pconrmax[2];
7868 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7869 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
cd2243fb 7870 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
47f8de53 7871 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
7872 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7873 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7874 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
7875 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
7876 TGeoPcon* ssdcableitsring3BB24pconshape[4];
7877 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7878 + (90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7879 - fgkSSDCableAngle),2);
7880 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+fgkSSDCableAngle-0.5*ssdcableangle,
7881 ssdcableangle-fgkSSDCableAngle
7882 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
7883 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7884 - fgkSSDCableAngle
7885 + 90.0-fgkSSDCablesPatchPanel2RB24Angle[1],2);
5ef8864c 7886 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+fgkSSDCableAngle-0.5*ssdcableangle,
47f8de53 7887 ssdcableangle-fgkSSDCableAngle
7888 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
7889 for(Int_t i=0;i<4;i++)
7890 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
7891 ssdcableitsring3BB24pconrmin[j],
7892 ssdcableitsring3BB24pconrmax[j]);
7893 TGeoVolume* ssdcableitsring3BB24pcon[4];
7894 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
7895 ssdcableitsring3BB24pconshape[0],fSSDCopper);
7896 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
7897 ssdcableitsring3BB24pconshape[1],fSSDCopper);
7898 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
7899 ssdcableitsring3BB24pconshape[2],fSSDCopper);
7900 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
7901 ssdcableitsring3BB24pconshape[3],fSSDCopper);
7902 for(Int_t i=0;i<4;i++){
7903 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
5ef8864c 7904 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
47f8de53 7905}
7906 ////////////////////////////////////
7907 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
7908 // + ssdcableitsring3BB24pconshape[1]->Capacity()
7909 // + ssdcableitsring3BB24pconshape[2]->Capacity()
7910 // + ssdcableitsring3BB24pconshape[3]->Capacity();
7911 ////////////////////////////////////
7912 // Volumes for Material Budget
7913 ////////////////////////////////////
7914 TGeoTube* ssdcablelay6materialbudgetubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax
7915 + fgkSSDCablesLay5RightSideWaterHeight,
7916 ssdcableslay6rightsideradiusmax
7917 + fgkSSDCablesLay5RightSideWaterHeight
7918 + fgkSSDCableMaterialBudgetHeight,0.5*ssdcablelay6rightsidelength);
7919 TGeoVolume* ssdcablelay6materialbudgetube = new TGeoVolume("SSDCableLay6MaterialBudgetTube",
7920 ssdcablelay6materialbudgetubeshape,
7921 fSSDCopper);
7922 ssdcablelay6materialbudgetube->SetLineColor(9);
7923 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,1,ssdcablelay6rightrans);
7924 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,2,ssdcablesLay6RightTubeToLeftrans);
7925
7926 TGeoPcon* ssdcablelay6materialbudgetpconshape =
7927 new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
7928 TGeoVolume* ssdcablelay6materialbudgetpcon;
7929 Double_t ssdcablelay6materialbudgetpconrmin[2];
7930 Double_t ssdcablelay6materialbudgetpconrmax[2];
7931 Double_t ssdcablelay6materialbudgetpconzsection[2];
7932 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
7933 + fgkSSDCablesLay5RightSideWaterHeight;
7934 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
7935 + fgkSSDCableMaterialBudgetHeight;
7936 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
7937 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
7938 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7939 + fgkEndCapSupportCenterLay6Position
7940 + ssdcablelay6rightsidelength;
7941 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7942 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
7943 ssdcablelay6materialbudgetpconzsection[i],
7944 ssdcablelay6materialbudgetpconrmin[i],
7945 ssdcablelay6materialbudgetpconrmax[i]);
7946 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
7947 ssdcablelay6materialbudgetpconshape,fSSDCopper);
7948 ssdcablelay6materialbudgetpcon->SetLineColor(9);
7949 for(Int_t i=0; i<4; i++){
7950 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
7951 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7952 }
7953////////////////////////////////////
7954 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
7955 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
7956 Double_t ssdcablesvolume = 0.0;
7957 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
7958 std::cout << ssdcablesvolume << std::endl;*/
7959 return ssdcablesmother;
7960 }
7961 ////////////////////////////////////////////////////////////////////////////////
d7599219 7962TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
b671cde1 7963 Double_t height, const char* shapename, Int_t isign) const{
44285dfa 7964 /////////////////////////////////////////////////////////////
7965 // Method generating an Arb shape
7966 /////////////////////////////////////////////////////////////
7967 const Int_t kvertexnumber = 8;
7968 const Int_t ktransvectnumber = 2;
b671cde1 7969 TVector3 vertex[kvertexnumber];
7970 TVector3 transvector[2];
7971 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
44285dfa 7972 /////////////////////////////////////////////////////////////
d7599219 7973 //Setting the vertices for TGeoArb8
44285dfa 7974 /////////////////////////////////////////////////////////////
b671cde1 7975 vertex[0] = *vertexpos[0];
7976 vertex[1] = *vertexpos[1];
7977 vertex[2] = vertex[1];
7978 vertex[3] = vertex[0];
7979 vertex[4] = *vertexpos[2];
7980 vertex[5] = *vertexpos[3];
7981 vertex[6] = vertex[5];
7982 vertex[7] = vertex[4];
7983
7984 // NB: order of points is clockwise
7985 if (isign < 0) {
7986 vertex[2] -= transvector[0];
7987 vertex[3] -= transvector[0];
7988 vertex[6] -= transvector[1];
7989 vertex[7] -= transvector[1];
7990 }
7991 else {
7992 vertex[0] += transvector[0];
7993 vertex[1] += transvector[0];
7994 vertex[4] += transvector[1];
7995 vertex[5] += transvector[1];
7996 }
7997
44285dfa 7998 /////////////////////////////////////////////////////////////
7999 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
b671cde1 8000 for(Int_t i = 0; i<kvertexnumber;i++) {
8001 arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
8002 }
8003
44285dfa 8004 return arbshape;
d7599219 8005}
bf210566 8006///////////////////////////////////////////////////////////////////////////////
8007TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8008 Double_t rmax, Int_t nedges, Double_t height){
8009 /////////////////////////////////////////////////////////////
8010 // Method generating Arc shape
8011 /////////////////////////////////////////////////////////////
8012 const Int_t kvertexnumber = 2*nedges+2;
8013 TGeoXtru* arcshape = new TGeoXtru(2);
8014 TVector3** vertexposition[2];
8015 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8016 Double_t angle = 0.;
8017 for(Int_t i=0; i<nedges+1; i++){
8018 angle = 90.+0.5*phi-i*(phi/nedges);
8019 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
8020 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
8021 }
8022 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8023 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8024 for(Int_t i=0; i<kvertexnumber; i++){
8025 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8026 yvertexpoints[i] = vertexposition[0][i]->Y();
8027 }
8028 else if(i>=1&&i<nedges+2)
8029 {
8030 xvertexpoints[i] = vertexposition[1][i-1]->X();
8031 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8032 }
8033 else
8034 {
8035 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8036 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8037 }
8038 }
8039 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8040 arcshape->DefineSection(0,-0.5*height);
8041 arcshape->DefineSection(1,0.5*height);
44285dfa 8042 /////////////////////////////////////////////////////////////
bf210566 8043 // Deallocating memory
44285dfa 8044 /////////////////////////////////////////////////////////////
bf210566 8045 for(Int_t i=0; i<2; i++){
8046 for(Int_t j=0; j<nedges+1; j++)
8047 delete vertexposition[i][j];
8048 delete [] vertexposition[i];
8049 }
8050 delete [] xvertexpoints;
8051 delete [] yvertexpoints;
8052 /////////////////////////////////////////////////////////////
8053 return arcshape;
d7599219 8054}
8055////////////////////////////////////////////////////////////////////////////////
851c0ce3 8056TGeoShape* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
9b0c60ab 8057 ///////////////////////////////////////////////////////////////////////
8058 // Method Generating the Screw Shape
8059 // radius[0]: outer radius
8060 // radius[1]: inner radius
8061 // edgesnumber[0]: outer number of edges
8062 // edgesnumber[1]: inner number of edges
8063 // section[0]: lower section position
8064 // section[1]: higher section position
8065 ///////////////////////////////////////////////////////////////////////
8066 Double_t outradius = radius[0];
8067 Double_t inradius = radius[1];
8068 Int_t outvertexnumber = edgesnumber[0];
8069 Int_t invertexnumber = edgesnumber[1];
851c0ce3 8070 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8071 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8072 for(Int_t i=0; i<outvertexnumber; i++){
9b0c60ab 8073 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8074 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8075 }
851c0ce3 8076 for(Int_t i=0; i<invertexnumber; i++){
8077 xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8078 yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
9b0c60ab 8079 }
851c0ce3 8080 TGeoXtru* screwshapeout = new TGeoXtru(2);
8081 screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8082 screwshapeout->DefineSection(0,section[0]);
8083 screwshapeout->DefineSection(1,section[1]);
8084 TGeoXtru* screwshapein = new TGeoXtru(2);
8085 screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8086 screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8087 screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8088 TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8089 TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8090
9b0c60ab 8091 delete [] xscrewvertex;
8092 delete [] yscrewvertex;
8093 return screwshape;
8094}
8095////////////////////////////////////////////////////////////////////////////////
851c0ce3 8096TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
9b0c60ab 8097 ///////////////////////////////////////////////////////////////////////
8098 // Method Generating the Hole Shape
8099 // radius of the Hole
8100 // nedges: number of edges to approximate the circle
8101 ///////////////////////////////////////////////////////////////////////
851c0ce3 8102 Double_t* xholevertex = new Double_t[nedges];
8103 Double_t* yholevertex = new Double_t[nedges];
8104 Double_t z = 0.5*(section[0]+section[1]);
8105 Double_t dz = 0.5*(section[1]-section[0]);
8106 TGeoTranslation *tr = 0;
8107 if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8108 tr = new TGeoTranslation(0.,0.,z);
8109 tr->RegisterYourself();
8110 }
8111 TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8112 for(Int_t i=0; i<nedges; i++){
8113 xholevertex[i] = radius*CosD(i*360./nedges);
8114 yholevertex[i] = radius*SinD(i*360./nedges);
9b0c60ab 8115 }
851c0ce3 8116 TGeoXtru* holeshapeout = new TGeoXtru(2);
8117 holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8118 holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8119 holeshapeout->DefineSection(1,section[1]+0.01);
8120 TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8121 TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8122
9b0c60ab 8123 delete [] xholevertex;
8124 delete [] yholevertex;
8125 return holeshape;
8126}
8127////////////////////////////////////////////////////////////////////////////////
44285dfa 8128TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
8129 /////////////////////////////////////////////////////////////
8130 // Given an axis specified by param, it gives the reflection of the point
8131 // respect to the axis
8132 /////////////////////////////////////////////////////////////
8133 TVector3* n = new TVector3(param[0],param[1],param[2]);
8134 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8135 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 8136 /////////////////////////////////////////////////////////////
8137 // Deallocating memory
8138 /////////////////////////////////////////////////////////////
8139 delete n;
8140 /////////////////////////////////////////////////////////////
44285dfa 8141 return reflectedvector;
d7599219 8142}
8143////////////////////////////////////////////////////////////////////////////////
bf210566 8144TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
d7599219 8145 Double_t dx,
8146 Double_t dy,
8147 Double_t dz) const{
44285dfa 8148 /////////////////////////////////////////////////////////////
d7599219 8149 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 8150 /////////////////////////////////////////////////////////////
bf210566 8151 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8152 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 8153 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 8154 hmatrix->SetTranslation(newvect);
8155 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8156 delete hmatrix;
8157 return matrix;
d7599219 8158}
8159////////////////////////////////////////////////////////////////////////////////
d7599219 8160TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 8161 /////////////////////////////////////////////////////////////
8162 // Method returning the Medium type
8163 /////////////////////////////////////////////////////////////
a3f8715e 8164 char ch[100];
d7599219 8165 sprintf(ch, "ITS_%s",mediumName);
8166 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8167 if (! medium)
160835d5 8168 AliError(Form("medium %s not found !\n", mediumName));
d7599219 8169 return medium;
8170}
8171////////////////////////////////////////////////////////////////////////////////
d7599219 8172void AliITSv11GeometrySSD::CreateMaterials(){
8173///////////////////////////////////
8174// This part has to be modified
8175///////////////////////////////////
8176 ///////////////////////////////////
8177 // Silicon for Sensor
8178 ///////////////////////////////////
bf210566 8179 fSSDSensorMedium = GetMedium("SI$");
d7599219 8180 ///////////////////////////////////
8181 // Silicon Mixture for Sensor
8182 ///////////////////////////////////
44285dfa 8183 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8184 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 8185 ///////////////////////////////////
8186 // Stiffener Components Materials
8187 ///////////////////////////////////
bf210566 8188 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 8189 ///////////////////////////
8190 // Stiffener Connectors
8191 ///////////////////////////
bf210566 8192 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 8193 ////////////////////////////////
8194 // Stiffener 0603-1812 Capacitor
8195 ////////////////////////////////
bf210566 8196 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8197 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
d7599219 8198 ///////////////////////////
8199 // Stiffener Hybrid Wire
8200 ///////////////////////////
bf210566 8201 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 8202 ///////////////////////////
8203 // Al for Cooling Block
8204 ///////////////////////////
bf210566 8205 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 8206 //////////////////////////////////////////////////////
8207 // Kapton and Al for Chip Cable Flex and Ladder Cables
8208 //////////////////////////////////////////////////////
bf210566 8209 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8210 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8211 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8212 fSSDAlTraceFlexMedium = GetMedium("AL$");
8213 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8214 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 8215 /////////////////////////////////////////////////////////////////
8216 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8217 //////////////////////////////////////////////////////////////////
44285dfa 8218 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 8219 /////////////////////////////////////////////////////////////////
8220 // G10 for Detector Leg, TubeHolder
8221 //////////////////////////////////////////////////////////////////
44285dfa 8222 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8223 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8224 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8225 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 8226 /////////////////////////////////////////////////////////////////
8227 // Water and Phynox for Cooling Tube
8228 //////////////////////////////////////////////////////////////////
bf210566 8229 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 8230 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 8231 /////////////////////////////////////////////////////////////////////
9b0c60ab 8232 // Material for Support Rings
8233 /////////////////////////////////////////////////////////////////////
8234 fSSDSupportRingAl = GetMedium("AL$");
47f8de53 8235 fSSDRohaCellCone = GetMedium("ROHACELL$");
9b0c60ab 8236 /////////////////////////////////////////////////////////////////////
bf210566 8237 fSSDAir = GetMedium("SDD AIR$");
47f8de53 8238 fSSDCopper = GetMedium("COPPER$");
bf210566 8239 fCreateMaterials = kTRUE;
d7599219 8240}
8241/////////////////////////////////////////////////////////////////////