]> 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
Several changes, mostly technical in nature: some mother volumes have been
[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 /////////////////////////////////////////////////////////////
1732 Int_t edgesnumber = 16;
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
2072 Double_t Router = fgkCoolingTubeSupportRmin*CosD(2*phi/nedges); // Recalc inner radius so that tube fits inside
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;
2252 const Int_t kmothervertexnumber = 12;
2253 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2254 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2255 ///////////////////////
2256 // Setting the vertices
2257 ///////////////////////
2258 xmothervertex[0][0] = -0.5*fgkSSDStiffenerLength;
2259 xmothervertex[0][1] = xmothervertex[0][0];
2260 xmothervertex[0][2] = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
2261 xmothervertex[0][3] = xmothervertex[0][2];
2262 xmothervertex[0][4] = xmothervertex[0][0];
2263 xmothervertex[0][5] = xmothervertex[0][4];
2264 xmothervertex[0][6] = -xmothervertex[0][0];
2265 xmothervertex[0][7] = xmothervertex[0][6];
2266 xmothervertex[0][8] = -xmothervertex[0][2];
2267 xmothervertex[0][9] = xmothervertex[0][8];
2268 xmothervertex[0][10] = xmothervertex[0][7];
2269 xmothervertex[0][11] = xmothervertex[0][10];
2270 for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
2271 for(Int_t i = 0; i<kmothernumber; i++){
2272 ymothervertex[i][0] = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
2273 + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
2274 ymothervertex[i][1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
2275 ymothervertex[i][2] = ymothervertex[i][1];
2276 ymothervertex[i][3] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
2277 ymothervertex[i][4] = ymothervertex[i][3];
2278 ymothervertex[i][5] = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
2279 ymothervertex[i][6] = ymothervertex[i][5];
2280 ymothervertex[i][7] = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
2281 ymothervertex[i][8] = ymothervertex[i][7];
2282 ymothervertex[i][9] = 0.5*fgkSSDStiffenerWidth;
2283 ymothervertex[i][10] = ymothervertex[i][9];
2284 ymothervertex[i][11] = ymothervertex[i][0];
2285 }
2286 TGeoXtru* ssdhybridmothershape[kmothernumber];
cd2243fb 2287 //TGeoVolume* ssdhybridmother[kmothernumber];
ca86fdb4 2288 TGeoVolumeAssembly* ssdhybridmother[kmothernumber];
bf210566 2289 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2290 for(Int_t i=0; i<kmothernumber; i++){
2291 ssdhybridmothershape[i] = new TGeoXtru(2);
2292 ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
2293 ymothervertex[i]);
cd2243fb 2294 /*
2295 cout << "ssd hybrid mother " << i << " polygon " << endl;
2296 for (Int_t lll = 0; lll < kmothervertexnumber; lll++) {
2297 cout << "vtx " << lll << ": " << xmothervertex[i][lll] << " " << ymothervertex[i][lll] << endl;
2298 }
2299 */
bf210566 2300 ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2301 -fgkSSDChipCablesHeight[i+2]);
2302 ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
cd2243fb 2303 // cout << " sections " << -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2304 // -fgkSSDChipCablesHeight[i+2] << " " << 0.5*fgkSSDStiffenerHeight << endl;
2305 //ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
2306 // fSSDAir);
ca86fdb4 2307 ssdhybridmother[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
bf210566 2308 }
2309 /////////////////////////////////////////////////////////////
2310 // SSD Stiffener
2311 /////////////////////////////////////////////////////////////
2312 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2313 0.5*fgkSSDStiffenerLength,
ca86fdb4 2314 0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
bf210566 2315 0.5*fgkSSDStiffenerHeight);
2316 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2317 fSSDStiffenerMedium);
2318 ssdstiffener->SetLineColor(fColorStiffener);
2319 TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
2320 for(Int_t i=0; i<kssdstiffenernumber; i++)
2321 ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
2322 /////////////////////////////////////////////////////////////
2323 // SSD Chip System
2324 /////////////////////////////////////////////////////////////
2325 TList* ssdchipsystemlist = GetSSDChipSystem();
2326 Double_t ssdchipseparation = fgkSSDSensorLength
2327 - 2.*fgkSSDModuleStiffenerPosition[1]
2328 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
2329 - 0.5*fgkSSDChipWidth);
2330 Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
2331 + fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
2332 TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
2333 - 0.5*ssdchipsystemlength,
2334 0.5*(ssdstiffenerseparation-ssdchipseparation),
2335 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
2336////////////////////////////
2337// Capacitor 0603-2200 nF
2338///////////////////////////
2339 const Int_t knapacitor0603number = 5;
2340 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
2341 0.5*fgkSSDCapacitor0603Length,
9f5fafaf 2342 0.5*(fgkSSDCapacitor0603Width),
bf210566 2343 0.5*fgkSSDCapacitor0603Height);
2344 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2345 fSSDStiffener0603CapacitorMedium);
2346 capacitor0603->SetLineColor(fColorAl);
bf210566 2347 for(Int_t i=0; i<kmothernumber; i++){
2348 for(Int_t j=0; j<kssdstiffenernumber; j++){
2349 ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
2350 for(Int_t k=1; k<knapacitor0603number+1; k++){
9f5fafaf 2351 ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
2352 new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
2353 j*ssdstiffenerseparation
2354 + 0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
2355 + (j==0? -1:+1)*fgkSSDCapacitor0603Width),
2356 - 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
bf210566 2357 }
2358 }
2359 ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
2360 ssdhybridlist->Add(ssdhybridmother[i]);
2361 }
2362/////////////////////////////////////////////////////////////
2363// Mother Volume Containing Capacitor Part
2364/////////////////////////////////////////////////////////////
2365 const Int_t kcapacitormothernumber = 8;
2366 Double_t xcapacitorvertex[kcapacitormothernumber];
2367 Double_t ycapacitorvertex[kcapacitormothernumber];
2368 ///////////////////////
2369 // Setting the vertices
2370 ///////////////////////
2371 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2372 xcapacitorvertex[1] = xcapacitorvertex[0];
2373 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2374 xcapacitorvertex[3] = xcapacitorvertex[2];
2375 xcapacitorvertex[4] = xcapacitorvertex[0];
2376 xcapacitorvertex[5] = xcapacitorvertex[0];
2377 xcapacitorvertex[6] = -xcapacitorvertex[0];
2378 xcapacitorvertex[7] = xcapacitorvertex[6];
2379 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2380 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2381 ycapacitorvertex[2] = ycapacitorvertex[1];
2382 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2383 ycapacitorvertex[4] = ycapacitorvertex[3];
2384 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2385 ycapacitorvertex[6] = ycapacitorvertex[5];
2386 ycapacitorvertex[7] = ycapacitorvertex[0];
2387 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2388 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2389 ycapacitorvertex);
2390 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2391 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
ca86fdb4 2392// TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2393// fSSDAir);
2394 TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
d7599219 2395////////////////////////////
bf210566 2396// Connector
d7599219 2397///////////////////////////
bf210566 2398 const Int_t kssdconnectornumber = 2;
2399 TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2400 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2401 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2402 + fgkSSDConnectorAlHeight};
2403 const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2404 TGeoVolume* ssdconnector[kssdconnectornumber];
2405 for(Int_t i=0; i<kssdconnectornumber; i++){
2406 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2407 0.5*fgkSSDConnectorWidth,
2408 0.5*((1-i)*fgkSSDConnectorAlHeight
2409 + i*fgkSSDConnectorNiHeight),
2410 i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2411 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2412 i==0 ? fSSDAlTraceFlexMedium
2413 : fSSDStiffenerConnectorMedium);
2414 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2415 }
2416 TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2417 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2418 + fgkSSDConnectorPosition[0]
2419 - fgkSSDConnectorSeparation
2420 - 1.5*fgkSSDConnectorLength,
2421 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2422 - fgkSSDConnectorPosition[1]
2423 - ssdconnectorshape[0]->GetDY(),0.0);
2424 ssdconnectortrans[1] = new TGeoTranslation(
2425 - ssdstiffenershape->GetDX()
2426 + fgkSSDConnectorPosition[0]
2427 - 0.5*fgkSSDConnectorLength,
2428 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2429 - fgkSSDConnectorPosition[1]
2430 - ssdconnectorshape[0]->GetDY(),0.0);
2431 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2432 - fgkSSDConnectorPosition[0]
2433 + fgkSSDConnectorSeparation
2434 + 1.5*fgkSSDConnectorLength,
2435 -(ssdstiffenershape->GetDY()
2436 - fgkSSDConnectorPosition[1]
2437 - ssdconnectorshape[0]->GetDY()),0.0);
2438 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2439 - fgkSSDConnectorPosition[0]
2440 + 0.5*fgkSSDConnectorLength,
2441 -(ssdstiffenershape->GetDY()
2442 - fgkSSDConnectorPosition[1]
2443 - ssdconnectorshape[0]->GetDY()),0.0);
2444 for(Int_t i=0; i<2*kssdconnectornumber; i++)
2445 for(Int_t j=0; j<kssdconnectornumber; j++)
2446 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2447////////////////////////////
2448// Capacitor 1812-330 nF
2449///////////////////////////
2450 Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2451 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2452 0.5*fgkSSDCapacitor1812Length,
2453 0.5*fgkSSDCapacitor1812Width,
bf210566 2454 0.5*fgkSSDCapacitor1812Height,
2455 ssdcapacitor1812origin);
44285dfa 2456 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2457 fSSDStiffener1812CapacitorMedium);
2458 capacitor1812->SetLineColor(fColorAl);
bf210566 2459 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2460 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2461 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2462 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
d7599219 2463////////////////////////////
2464//Hybrid Wire
2465////////////////////////////
44285dfa 2466 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2467 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2468 - fgkSSDConnectorSeparation;
44285dfa 2469 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2470 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
60e55aee 2471 Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2472
44285dfa 2473 Double_t wireangle = TMath::ATan(wirex/wirey);
2474 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2475 fgkSSDWireRadius, 0.5*ssdwireradius);
2476 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2477 fSSDStiffenerHybridWireMedium);
2478 hybridwire->SetLineColor(fColorPhynox);
2479 TGeoCombiTrans* hybridwirecombitrans[2];
2480 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2481 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2482 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2483 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2484 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2485 ssdstiffenershape->GetDZ()
2486 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
d7599219 2487 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2488 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2489 0.0,
2490 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2491 0.0,
2492 new TGeoRotation("HybridWireRot2",
2493 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2494 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2495 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2496 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2497 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2498 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2499 /////////////////////////////////////////////////////////////
bf210566 2500 // Deallocating memory
44285dfa 2501 /////////////////////////////////////////////////////////////
bf210566 2502 delete hybridwirecombitrans[0];
2503 delete hybridwirecombitrans[1];
2504 delete ssdchipsystemlist;
2505 return ssdhybridlist;
2506 /////////////////////////////////////////////////////////////
2507}
2508///////////////////////////////////////////////////////////////////////////////
2509TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2510 /////////////////////////////////////////////////////////////
2511 // SSD Cooling Block System
2512 /////////////////////////////////////////////////////////////
2513 // SSD Cooling Block and Cooling Tube Transformations
2514 /////////////////////////////////////////////////////////////
2515 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2516 localcoolingblockrot->SetAngles(0.,90.,0.);
535e8862 2517 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
bf210566 2518 TVector3* coolingblocktransvector;
2519 coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2520 + fgkSSDCoolingBlockLength,
2521 fgkSSDSensorLength
2522 - 2.*fgkSSDModuleStiffenerPosition[1]
2523 - fgkSSDCoolingBlockWidth);
2524 const Int_t kcoolingblocktransnumber = 2;
2525 const Int_t kcoolingblocknumber = 4;
2526 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2527 TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2528 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2529 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2530 TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2531 localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
535e8862 2532 0.5*fgkSSDCoolingBlockWidth,
2533 fgkSSDCoolingBlockHoleCenter);
2534 TGeoCombiTrans localcoolingtubematrix (*localcoolingtubetrans,*localcoolingtuberot);
bf210566 2535 Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2536 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
535e8862 2537 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2538 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X()+2*coolingtubedistance,
2539 j*coolingblocktransvector->Y(),
2540 - 0.5*(fgkSSDCoolingBlockHoleCenter
2541 + fgkCoolingTubeRmax));
2542 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
2543 coolingtubematrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingtubematrix);
2544 }
d7599219 2545 }
bf210566 2546 /////////////////////////////////////////////////////////////
2547 // Virtual Volume containing CoolingBlock System
2548 /////////////////////////////////////////////////////////////
2549 TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2550 const Int_t kmothervertexnumber = 16;
2551 Double_t xmothervertex[kmothervertexnumber];
2552 Double_t ymothervertex[kmothervertexnumber];
2553 ///////////////////////
2554 // Setting the vertices
2555 ///////////////////////fgkCoolingTubeSupportRmax
2556 xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2557 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2558 + fgkSSDCoolingBlockWidth;
2559 xmothervertex[2] = coolingblocktransvector->X()
2560 + fgkSSDCoolingBlockLength
2561 + 4*coolingtubedistance;
2562 ymothervertex[2] = ymothervertex[1];
2563 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2564 xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2565 ymothervertex[4] = ymothervertex[0];
2566 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2567 xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2568 ymothervertex[6] = ymothervertex[5];
2569 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2570 - fgkSSDCoolingBlockWidth;
2571 xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2572 xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2573 - coolingtubedistance;
2574 xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2575 ymothervertex[10] = ymothervertex[9];
2576 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2577 xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2578 xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2579 xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2580 ymothervertex[14] = ymothervertex[13];
2581 xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2582 //////////////////////////////////////////////////////////
2583 coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2584 xmothervertex,ymothervertex);
2585 coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2586 + fgkCoolingTubeRmax));
2587 coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2588 + fgkCoolingTubeRmax));
ca86fdb4 2589 TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
2590// TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
2591// coolingsystemothershape,fSSDAir);
bf210566 2592 /////////////////////////////////////////////////////////////
2593 // SSD Cooling Tube Part
2594 /////////////////////////////////////////////////////////////
cd2243fb 2595 /*
bf210566 2596 TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
2597 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
ca86fdb4 2598 0.5*(fgkSSDCoolingBlockWidth-fgkSSDTolerance));
bf210566 2599 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
ca86fdb4 2600 0.5*(fgkSSDCoolingBlockWidth-fgkSSDTolerance));
bf210566 2601 TGeoVolume* coolingtube[fgkcoolingtubenumber];
2602 coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
2603 fSSDCoolingTubePhynox);
2604 coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
2605 fSSDCoolingTubeWater);
2606 coolingtube[0]->SetLineColor(fColorPhynox);
2607 coolingtube[1]->SetLineColor(fColorWater);
cd2243fb 2608 */
bf210566 2609 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2610 /////////////////////////////////////////////////////////////
2611 // Adding Cooling block to mother volume
2612 /////////////////////////////////////////////////////////////
2613 for(Int_t i=0; i<kcoolingblocknumber; i++){
9f5fafaf 2614 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
cd2243fb 2615 //coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
2616 //coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
d7599219 2617 }
bf210566 2618 /////////////////////////////////////////////////////////////
2619 // Deallocating memory
2620 /////////////////////////////////////////////////////////////
2621 delete coolingblocktransvector;
bf210566 2622 delete localcoolingblockrot;
cd2243fb 2623 //delete localcoolingtubetrans;
2624 //delete localcoolingtuberot;
bf210566 2625 /////////////////////////////////////////////////////////////
2626 // Checking overlaps
2627 /////////////////////////////////////////////////////////////
6727e2db 2628 //coolingsystemother->CheckOverlaps(0.01);
bf210566 2629 /////////////////////////////////////////////////////////////
2630 return coolingsystemother;
d7599219 2631}
2632/////////////////////////////////////////////////////////////////////////////////
bf210566 2633TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2634 /////////////////////////////////////////////////////////////
bf210566 2635 // SSD Flex
44285dfa 2636 /////////////////////////////////////////////////////////////
bf210566 2637 const Int_t kssdflexlayernumber = 2;
2638 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2639 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2640 const Int_t kmothervertexnumber = 17;
2641 Double_t xmothervertex[kmothervertexnumber];
2642 Double_t ymothervertex[kmothervertexnumber];
2643 /////////////////////////////////////////////
2644 // Auxiliary variables for vertex positioning
2645 /////////////////////////////////////////////
2646 const Int_t kssdflexboxnumber = 5;
44285dfa 2647 Double_t ssdflexboxlength[kssdflexboxnumber];
2648 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2649 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2650 * fgkSSDChipSeparationLength
2651 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2652 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2653 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2654 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2655 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2656 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2657 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2658 - ssdflexboxlength[1];
44285dfa 2659 Double_t ssdflexboxwidth[kssdflexboxnumber];
2660 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2661 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2662 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2663 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2664 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2665 ///////////////////////
2666 // Setting the vertices
2667 ///////////////////////
2668 xmothervertex[0] = 0.0;
2669 xmothervertex[1] = xmothervertex[0];
2670 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2671 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2672 + ssdflexboxlength[4];
2673 xmothervertex[4] = xmothervertex[3];
2674 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2675 xmothervertex[6] = xmothervertex[5];
2676 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2677 xmothervertex[8] = xmothervertex[7];
2678 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2679 xmothervertex[10] = xmothervertex[9];
2680 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2681 xmothervertex[12] = xmothervertex[11];
2682 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2683 xmothervertex[14] = xmothervertex[13];
2684 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2685 xmothervertex[16] = xmothervertex[15];
2686 ymothervertex[0] = 0.0;
2687 ymothervertex[1] = fgkSSDFlexWidth[1];
2688 ymothervertex[2] = fgkSSDFlexWidth[0];
2689 ymothervertex[3] = ymothervertex[2];
2690 ymothervertex[4] = ymothervertex[0];
2691 ymothervertex[5] = ymothervertex[4];
2692 ymothervertex[6] = ssdflexboxwidth[2];
2693 ymothervertex[7] = ymothervertex[6];
2694 ymothervertex[8] = ymothervertex[0];
2695 ymothervertex[9] = ymothervertex[8];
2696 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2697 ymothervertex[11] = ymothervertex[10];
2698 ymothervertex[12] = ymothervertex[0];
2699 ymothervertex[13] = ymothervertex[12];
2700 ymothervertex[14] = ymothervertex[7];
2701 ymothervertex[15] = ymothervertex[14];
2702 ymothervertex[16] = ymothervertex[0];
2703 /////////////////////////////////////////////////////////////
2704 // First Mother Volume containing SSDFlex
2705 /////////////////////////////////////////////////////////////
2706 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2707 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2708 ymothervertex);
2709 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2710 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
ca86fdb4 2711 TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2712// TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2713// fSSDAir);
bf210566 2714 /////////////////////////////////////////////////////////////
2715 // SSDFlex Layer Shapes
2716 /////////////////////////////////////////////////////////////
2717 for(Int_t i=0; i<kssdflexlayernumber; i++){
2718 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2719 ymothervertex);
2720 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2721 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2722 }
2723 /////////////////////////////////////
2724 // Setting Layers into Mother Volume
2725 /////////////////////////////////////
2726 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2727 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2728 fSSDKaptonFlexMedium};
2729 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2730 "AlFlexLay2","KaptonFlexLay2"};
2731 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2732 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2733 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2734 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2735 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2736 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2737 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2738 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2739 + fgkSSDFlexHeight[1]));
2740 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2741 }
bf210566 2742 return ssdflexmother;
d7599219 2743}
2744/////////////////////////////////////////////////////////////////////////////////
bf210566 2745TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2746 /////////////////////////////////////////////////////////////
2747 // Method generating SSD End Flex
d7599219 2748 /////////////////////////////////////////
bf210566 2749 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2750 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2751 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2752 * TMath::DegToRad()*ssdflexradiusmax
2753 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 2754 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2755 - 0.1*fgkSSDFlexFullLength;
bf210566 2756 const Int_t knedges = 20;
2757 const Int_t karcnumber = 2;
2758 TVector3* vertexposition[karcnumber*(knedges+1)];
2759 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2760 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2761 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2762 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2763 - 90.0*TMath::DegToRad()};
2764 TVector3* referencetrans[karcnumber];
2765 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2766 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2767 radius[0]);
2768 referencetrans[1] = new TVector3(referencetrans[0]->X()
2769 + fgkSSDFlexLength[2],
2770 - fgkSSDStiffenerHeight);
2771for(Int_t i=0; i<karcnumber; i++){
2772 for(Int_t j=0; j<knedges+1; j++){
2773 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2774 radius[i]*SinD(angle[i]));
2775 angle[i] += deltangle[i]*(1.0-2.0*i);
2776 }
2777 }
2778 ///////////////////////
2779 // Setting the vertices
2780 ///////////////////////
2781 const Int_t kendflexlayernumber = 4;
2782 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2783 TVector3** vertex[kendflexlayernumber];
2784 for(Int_t i=0; i<kendflexlayernumber; i++)
2785 vertex[i] = new TVector3*[kendflexvertexnumber];
2786 TVector3* transvector[kendflexlayernumber+1];
2787 TVector3* deltatransvector = new TVector3();
2788 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2789 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2790 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2791 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2792 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2793 * CosD(fgkSSDFlexAngle),
2794 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2795 * SinD(fgkSSDFlexAngle),0.0);
2796 *transvector[i] = *transvector[i-1]+*deltatransvector;
2797 }
2798 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2799 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2800 for(Int_t i=0; i<karcnumber; i++){
2801 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2802 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2803 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2804 /radius[i];
2805 }
2806 }
2807 for(Int_t i=0; i<kendflexlayernumber; i++){
2808 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2809 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2810 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2811 if(j<(knedges+1)){
2812 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2813 vertexposition[j]->Y()*ratioradius[0][i+1]);
2814 vertex[i][j+2]->RotateZ(referenceangle[0]);
2815 *vertex[i][j+2] += *referencetrans[0];
2816 vertex[i][4*(knedges+1)-j+1] =
2817 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2818 vertexposition[j]->Y()*ratioradius[0][i]);
2819 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2820 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2821 }
2822 else{
2823
2824 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2825 vertexposition[j]->Y()*ratioradius[1][i+1]);
2826 vertex[i][j+2]->RotateZ(referenceangle[1]);
2827 *vertex[i][j+2] += *referencetrans[1];
2828 vertex[i][4*(knedges+1)-j+1] =
2829 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2830 vertexposition[j]->Y()*ratioradius[1][i]);
2831 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2832 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2833 }
2834 }
2835 }
44285dfa 2836 /////////////////////////////////////////////////////////////
bf210566 2837 // First Mother Volume containing SSDEndFlex
2838 /////////////////////////////////////////////////////////////
2839 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2840 Double_t xmothervertex[kendflexvertexnumber];
2841 Double_t ymothervertex[kendflexvertexnumber];
2842 xmothervertex[0] = vertex[0][0]->X();
2843 ymothervertex[0] = vertex[0][0]->Y();
2844 for(Int_t i=1; i<kendflexvertexnumber; i++){
2845 if(i<2*(knedges+1)+2){
2846 xmothervertex[i] = vertex[3][i]->X();
2847 ymothervertex[i] = vertex[3][i]->Y();
2848 }
2849 else{
2850 xmothervertex[i] = vertex[0][i]->X();
2851 ymothervertex[i] = vertex[0][i]->Y();
2852 }
2853 }
2854 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2855 xmothervertex,ymothervertex);
2856 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2857 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
0fb26117 2858// TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2859// ssdendflexmothershape,fSSDAir);
2860 TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
bf210566 2861 //////////////////////////////////////
2862 // End Flex TGeoXtru Layer Definition
2863 //////////////////////////////////////
2864 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2865 TGeoVolume* ssdendflex[kendflexlayernumber];
2866 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2867 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2868 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2869 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2870 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2871 fSSDKaptonFlexMedium};
2872 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2873 "AlEndFlexLay2","KaptonEndFlexLay2"};
2874 for(Int_t i=0; i<kendflexlayernumber; i++){
2875 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2876 xvertex[i][j] = vertex[i][j]->X();
2877 yvertex[i][j] = vertex[i][j]->Y();
2878 }
2879 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2880 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2881 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2882 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2883 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2884 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2885 ssdendflexmother->AddNode(ssdendflex[i],1);
2886 }
44285dfa 2887 /////////////////////////////////////////////////////////////
bf210566 2888 // Deallocating memory
44285dfa 2889 /////////////////////////////////////////////////////////////
bf210566 2890 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2891 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2892 for(Int_t i=0; i<kendflexlayernumber; i++){
2893 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2894 delete [] vertex[i];
2895 }
2896 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2897 delete deltatransvector;
44285dfa 2898 /////////////////////////////////////////////////////////////
6727e2db 2899 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 2900 return ssdendflexmother;
d7599219 2901}
9b0c60ab 2902///////////////////////////////////////////////////////////////////////////////
bf210566 2903TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 2904 /////////////////////////////////////////////////////////////
9b0c60ab 2905 // Method generating the Mounting Block
bf210566 2906 /////////////////////////////////////////////////////////////
9b0c60ab 2907 const Int_t kvertexnumber = 8;
2908 Double_t xvertex[kvertexnumber];
2909 Double_t yvertex[kvertexnumber];
2910 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2911 xvertex[1] = xvertex[0];
2912 xvertex[2] = -xvertex[0];
2913 xvertex[3] = xvertex[2];
2914 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2915 - fgkSSDMountingBlockLength[2]);
2916 xvertex[5] = xvertex[4];
2917 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2918 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2919 - fgkSSDMountingBlockScrewHoleRadius[0];
2920 xvertex[7] = xvertex[6];
2921 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 2922 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 2923 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2924 yvertex[2] = yvertex[1];
2925 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2926 yvertex[4] = yvertex[3];
2927 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2928 - fgkSSDMountingBlockHeight[0];
2929 yvertex[6] = yvertex[5];
2930 yvertex[7] = yvertex[0];
160835d5 2931
9b0c60ab 2932 ///////////////////////////////////////////////////////////////////////
2933 // TGeoXTru Volume definition for Mounting Block Part
2934 ///////////////////////////////////////////////////////////////////////
2935 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2936 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2937 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2938 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 2939 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 2940 ssdmountingblockshape,
2941 fSSDMountingBlockMedium);
2942 ssdmountingblock->SetLineColor(fColorG10);
2943 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2944 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2945 TGeoRotation* mountingblockrot = new TGeoRotation();
2946 mountingblockrot->SetAngles(90.,180.,-90.);
2947 mountingblockcombitrans->SetRotation(*mountingblockrot);
2948 /////////////////////////////////////////////////////////////
2949 // Generating the Mounting Block Screw Vertices
2950 /////////////////////////////////////////////////////////////
2951 const Int_t kscrewvertexnumber = 15;
2952 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
2953 - fgkSSDMountingBlockScrewHoleEdge)
2954 / fgkSSDMountingBlockScrewHoleRadius[0])
2955 * TMath::RadToDeg();
2956 Double_t phi0 = 90.+alpha;
2957 Double_t phi = 270.-2*alpha;
2958 Double_t deltaphi = phi/kscrewvertexnumber;
2959 TVector3* screwvertex[kscrewvertexnumber+1];
2960 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
2961 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
2962 *CosD(phi0+i*deltaphi),
2963 fgkSSDMountingBlockScrewHoleRadius[0]
2964 *SinD(phi0+i*deltaphi));
2965 Double_t xscrewvertex[kscrewvertexnumber+6];
2966 Double_t yscrewvertex[kscrewvertexnumber+6];
2967 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
2968 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
2969 - fgkSSDMountingBlockScrewHoleEdge);
2970 xscrewvertex[1] = xscrewvertex[0];
2971 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2972 xscrewvertex[2] = screwvertex[0]->X();
2973 yscrewvertex[2] = yscrewvertex[1];
2974 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
2975 xscrewvertex[i+3] = screwvertex[i]->X();
2976 yscrewvertex[i+3] = screwvertex[i]->Y();
2977 }
2978 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2979 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
2980 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
2981 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
2982 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
2983 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
2984 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
2985 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
2986 + fgkSSDMountingBlockHeight[2]);
2987 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
2988 ssdmountingblockscrewshape,
2989 fSSDMountingBlockMedium);
2990 ssdmountingblockscrew->SetLineColor(fColorG10);
2991 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
2992 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
2993 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2994 - yscrewvertex[1],
2995 0.5*fgkSSDMountingBlockHeight[0]
2996 - fgkSSDMountingBlockHeight[2]
2997 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2998 + fgkSSDMountingBlockHeight[2]
2999 - yvertex[0]));
3000 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3001 -0.5*fgkSSDMountingBlockScrewHoleEdge,
3002 yscrewvertex[1]
3003 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3004 +fgkSSDMountingBlockHeight[2]
3005 -yvertex[0]));
3006 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3007 yscrewvertex[1],
3008 - 0.5*fgkSSDMountingBlockHeight[0]
3009 + fgkSSDMountingBlockHeight[2]
3010 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3011 + fgkSSDMountingBlockHeight[2]
3012 - yvertex[0]));
3013 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3014 yscrewvertex[1],
3015 - yscrewvertex[1]
3016 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3017 + fgkSSDMountingBlockHeight[2]
3018 - yvertex[0]));
3019 TGeoRotation* ssdmountingblockscrewrot[4];
3020 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3021 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3022 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3023 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3024 for(Int_t i=1; i<4; i++)
3025 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3026 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3027 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3028 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3029 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3030 + xvertex[0],yscrewvertex[1]
3031 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3032 + fgkSSDMountingBlockHeight[2]
3033 - yvertex[0]),0.);
3034 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3035 for(Int_t i=0; i<4; i++){
3036 ssdmountingblockscrewmatrix[i] =
3037 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3038 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3039 }
3040 ///////////////////////////////////////////////////////////////////////
3041 // TGeoXtru for Mother Volume
3042 ///////////////////////////////////////////////////////////////////////
3043 const Int_t kvertexmothernumber = 12;
3044 Double_t xmothervertex[kvertexmothernumber];
3045 Double_t ymothervertex[kvertexmothernumber];
3046 for(Int_t i=0; i<6; i++){
3047 xmothervertex[i] = xvertex[i];
3048 ymothervertex[i] = yvertex[i];
3049 }
3050 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3051 ymothervertex[6] = ymothervertex[5];
3052 xmothervertex[7] = xmothervertex[6];
3053 ymothervertex[7] = ymothervertex[4];
3054 xmothervertex[8] = xmothervertex[7]
3055 + 0.5*(fgkSSDMountingBlockLength[1]
3056 - fgkSSDMountingBlockLength[2]);
3057 ymothervertex[8] = ymothervertex[4];
3058 xmothervertex[9] = xmothervertex[8];
3059 ymothervertex[9] = ymothervertex[2];
3060 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3061 ymothervertex[10] = ymothervertex[1];
3062 xmothervertex[11] = xmothervertex[10];
3063 ymothervertex[11] = ymothervertex[0];
3064 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3065 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3066 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3067 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3068 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3069 ssdmountingblockmothershape,
3070 fSSDAir);
3071 /////////////////////////////////////////////////////////////
3072 // Placing the Volumes into Mother Volume
3073 /////////////////////////////////////////////////////////////
3074 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3075 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3076 for(Int_t i=0; i<4; i++)
3077 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3078 ssdmountingblockscrewmatrix[i]);
3079 /////////////////////////////////////////////////////////////
3080 // Deallocating memory
3081 /////////////////////////////////////////////////////////////
3082 delete mountingblockrot;
3083 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3084 delete ssdmountingblockglobalrot;
3085 delete ssdmountingblockglobaltrans;
3086 /////////////////////////////////////////////////////////////
3087 return ssdmountingblockmother;
3088}
3089///////////////////////////////////////////////////////////////////////////////
3090 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3091 /////////////////////////////////////////////////////////////
3092 // Method generating the Mounting Block Clip
3093 /////////////////////////////////////////////////////////////
3094 const Int_t kmothervertexnumber = 10;
3095 Double_t xmothervertex[kmothervertexnumber];
3096 Double_t ymothervertex[kmothervertexnumber];
3097 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3098 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3099 xmothervertex[1] = xmothervertex[0];
3100 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3101 - fgkMountingBlockClibScrewRadius);
3102 xmothervertex[3] = xmothervertex[2];
3103 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3104 xmothervertex[5] = xmothervertex[4];
3105 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3106 xmothervertex[7] = xmothervertex[6];
3107 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3108 xmothervertex[9] = xmothervertex[8];
3109 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 3110 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 3111 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3112 ymothervertex[2] = ymothervertex[1];
3113 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3114 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3115 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3116 ymothervertex[4] = ymothervertex[3];
3117 ymothervertex[5] = ymothervertex[2];
3118 ymothervertex[6] = ymothervertex[5];
3119 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3120 ymothervertex[8] = ymothervertex[7];
3121 ymothervertex[9] = ymothervertex[0];
160835d5 3122
9b0c60ab 3123 ///////////////////////////////////////////////////////////////////////
3124 // TGeoXTru Volume definition for Mounting Block Clip Part
3125 ///////////////////////////////////////////////////////////////////////
3126 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3127 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3128 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3129 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3130 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3131 ssdmountingblockclipshape,fSSDAir);
3132 ssdmountingblockclip->SetLineColor(4);
3133 ///////////////////////////////////////////////////////////////////////
3134 // TGeoXTru Volume definition for Clip
3135 ///////////////////////////////////////////////////////////////////////
3136 const Int_t kclipvertexnumber = 6;
3137 Double_t xclipvertex[kclipvertexnumber];
3138 Double_t yclipvertex[kclipvertexnumber];
3139 xclipvertex[0] = xmothervertex[0];
3140 xclipvertex[1] = xclipvertex[0];
3141 xclipvertex[2] = xmothervertex[6];
3142 xclipvertex[3] = xclipvertex[2];
3143 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3144 xclipvertex[5] = xclipvertex[4];
3145 yclipvertex[0] = ymothervertex[0];
3146 yclipvertex[1] = ymothervertex[1];
3147 yclipvertex[2] = yclipvertex[1];
3148 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3149 yclipvertex[4] = yclipvertex[3];
3150 yclipvertex[5] = yclipvertex[0];
3151 TGeoXtru* clipshape = new TGeoXtru(2);
3152 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3153 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3154 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3155 + fgkMountingBlockClibWidth);
3156 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3157 clip->SetLineColor(18);
3158 ///////////////////////////////////////////////////////////////////////
3159 // Ladder Support Piece
3160 ///////////////////////////////////////////////////////////////////////
3161 const Int_t ksupportvertexnumber = 4;
3162 Double_t xsupportvertex[ksupportvertexnumber];
3163 Double_t ysupportvertex[ksupportvertexnumber];
3164 xsupportvertex[0] = xclipvertex[5];
3165 xsupportvertex[1] = xsupportvertex[0];
3166 xsupportvertex[2] = xmothervertex[9];
3167 xsupportvertex[3] = xsupportvertex[2];
3168 ysupportvertex[0] = yclipvertex[0];
3169 ysupportvertex[1] = yclipvertex[3];
3170 ysupportvertex[2] = ysupportvertex[1];
3171 ysupportvertex[3] = ysupportvertex[0];
3172 TGeoXtru* supportshape = new TGeoXtru(2);
3173 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3174 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3175 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3176 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3177 support->SetLineColor(9);
3178 ///////////////////////////////////////////////////////////////////////
3179 // TGeoXTru Volume definition for Screw
3180 ///////////////////////////////////////////////////////////////////////
3181 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3182 0.5*fgkMountingBlockClibScrewRadius};
3183 Int_t edgesnumber[2] = {50,6};
3184 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3185 +0.5*(ymothervertex[3]-ymothervertex[2])};
851c0ce3 3186 TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
9b0c60ab 3187 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3188 clipscrew->SetLineColor(12);
3189 TGeoRotation* screwrot = new TGeoRotation();
3190 screwrot->SetAngles(0.,90.,0.);
3191 TGeoTranslation* screwtrans = new TGeoTranslation();
3192 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3193 0.5*(ymothervertex[3]+ymothervertex[2]),
3194 0.5*fgkSSDMountingBlockWidth+
3195 -0.5*fgkMountingBlockSupportWidth[0]);
3196 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3197 ///////////////////////////////////////////////////////////////////////
3198 // Placing the Volumes
3199 ///////////////////////////////////////////////////////////////////////
3200 ssdmountingblockclip->AddNode(clip,1);
3201 ssdmountingblockclip->AddNode(support,1);
3202 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3203 /////////////////////////////////////////////////////////////
3204 // Deallocating memory
3205 /////////////////////////////////////////////////////////////
3206 delete screwtrans;
3207 delete screwrot;
3208 /////////////////////////////////////////////////////////////
3209 return ssdmountingblockclip;
d7599219 3210}
bf210566 3211///////////////////////////////////////////////////////////////////////////////
cd2243fb 3212void AliITSv11GeometrySSD::CreateCoolingTubes() {
44285dfa 3213 /////////////////////////////////////////////////////////////
bf210566 3214 // Method generating the Cooling Tube
cd2243fb 3215 // sets fcoolingtube and returns list for endladdercoolingtube
44285dfa 3216 /////////////////////////////////////////////////////////////
cd2243fb 3217 TGeoTube *coolingtubeshape[2];
3218 // Ladder Cooling Tubes
3219
3220 // MvL: Simplified cooling tubes
3221 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
3222 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
3223
3224 // End Ladder Cooling Tubes
3225 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3226 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3227 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3228
3229 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
3230 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3231 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
3232 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3233 endladdercoolingtubeshape[0][0]->GetDz());
3234 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3235 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
3236 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3237 endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
3238 // Ladder Cooling Tubes
3239 TGeoVolume* coolingtube[2];
3240 coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
3241 coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
3242 coolingtube[0]->SetLineColor(fColorPhynox);
3243 coolingtube[1]->SetLineColor(fColorWater);
3244
3245 // End Ladder Cooling Tubes
3246 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3247 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3248 endladdercoolingtube[i] = new TGeoVolume*[2];
3249 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3250 endladdercoolingtubeshape[0][0],
3251 fSSDCoolingTubePhynox);
3252 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3253 endladdercoolingtubeshape[0][1],
3254 fSSDCoolingTubeWater);
3255 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3256 endladdercoolingtubeshape[1][0],
3257 fSSDCoolingTubePhynox);
3258 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3259 endladdercoolingtubeshape[1][1],
3260 fSSDCoolingTubeWater);
3261 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3262 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3263 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3264 }
0fb26117 3265
bf210566 3266 /////////////////////////////////////////////////////////////
3267 // Virtual Volume containing Cooling Tubes
3268 /////////////////////////////////////////////////////////////
9b0c60ab 3269 // Ladder Cooling Tubes
cd2243fb 3270 TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
3271 coolingtubeshape[0]->GetRmax(),
3272 coolingtubeshape[0]->GetDz());
3273 fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
3274 fcoolingtube->AddNode(coolingtube[0],1);
3275 fcoolingtube->AddNode(coolingtube[1],1);
3276
9b0c60ab 3277 // End Ladder Cooling Tubes
3278 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3279 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
cd2243fb 3280 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3281 endladdercoolingtubeshape[i][0]->GetRmax(),
3282 endladdercoolingtubeshape[i][0]->GetDz());
3283 fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3284 endladdervirtualcoolingtubeshape[0],
3285 fSSDAir);
3286 fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3287 endladdervirtualcoolingtubeshape[1],
3288 fSSDAir);
3289 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3290 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3291 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3292 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
d7599219 3293}
bf210566 3294///////////////////////////////////////////////////////////////////////////////
3295TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3296 /////////////////////////////////////////////////////////////
bf210566 3297 // Method generating SSD Cooling Block
44285dfa 3298 /////////////////////////////////////////////////////////////
bf210566 3299 const Int_t kvertexnumber = 8;
3300 ///////////////////////////////////////
3301 // Vertex Positioning for TGeoXTru
3302 ///////////////////////////////////////
3303 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3304 vertexposition[0] = new TVector3(0.0,0.0);
3305 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3306 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3307 vertexposition[1]->Y());
3308 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3309 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3310 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3311 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3312 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3313 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3314 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3315 - fgkSSDCoolingBlockHoleLength[0]
3316 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3317 fgkSSDCoolingBlockHeight[0]
3318 - fgkSSDCoolingBlockHoleRadius[1],
3319 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3320 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3321 - fgkSSDCoolingBlockHoleLength[0]),
3322 vertexposition[6]->Y());
3323 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3324 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3325 Double_t phi = 180.-alpha;
3326 Double_t psi = 180.+2.*alpha;
3327 Double_t deltapsi = psi/nedges;
3328 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3329 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3330 fgkSSDCoolingBlockHoleCenter);
3331 for(Int_t i=0; i<nedges+1; i++){
3332 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3333 radius*SinD(phi+i*deltapsi));
3334 *vertexposition[kvertexnumber+i] += (*transvector);
3335 }
3336 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3337 for(Int_t i=0; i<kvertexnumber; i++)
3338 vertexposition[kvertexnumber+nedges+1+i] =
3339 GetReflection(vertexposition[kvertexnumber-1-i],param);
3340 ///////////////////////////////////////////////////////////////////////
3341 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3342 ///////////////////////////////////////////////////////////////////////
3343 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3344 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3345 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3346 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3347 xvertexpoints[i] = vertexposition[i]->X();
3348 yvertexpoints[i] = vertexposition[i]->Y();
3349 }
3350 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3351 yvertexpoints);
3352 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3353 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3354 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3355 ssdcoolingblockshape,
3356 fSSDAlCoolBlockMedium);
3357 ssdcoolingblock->SetLineColor(fColorAl);
3358 /////////////////////////////////////////////////////////////
3359 // Deallocating memory
3360 /////////////////////////////////////////////////////////////
3361 delete [] vertexposition;
7b208ef4 3362 delete [] xvertexpoints;
3363 delete [] yvertexpoints;
bf210566 3364 /////////////////////////////////////////////////////////////
3365 return ssdcoolingblock;
3366}
3367/////////////////////////////////////////////////////////////////////////////////
cd2243fb 3368TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeight, Int_t nedges){
d7599219 3369 ///////////////////////////////////////////////////////
cd2243fb 3370 static const Int_t kssdchipcablesnumber = 2; // Number of cables: left and right
3371 static const Int_t kssdchipcableslaynumber = 2; // Number of layers: Al and Kapton
3372 static const Int_t kvertexnumber = 4*(nedges+1)+4;
bf210566 3373 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3374 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
cd2243fb 3375 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
bf210566 3376 - fgkSSDChipCablesHeight[0]
3377 - fgkSSDChipCablesHeight[1]);
3378 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3379 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3380 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3381 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3382 - ssdchipcablesradius[0]
3383 - fgkSSDChipCablesWidth[1]
3384 - fgkSSDChipCablesWidth[2]);
3385 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3386 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3387 + fgkSSDChipCablesHeight[1]
3388 + fgkSSDSensorHeight);
d7599219 3389 ///////////////////////////////////////////////////////
bf210566 3390 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3391 ///////////////////////////////////////////////////////
3392 TVector3** vertexposition[kssdchipcableslaynumber];
3393 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3394 new TVector3*[4*(nedges+1)+4];
3395 Double_t ratio[4];
3396 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3397 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3398 / ssdchipcablesradius[0];
3399 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3400 / ssdchipcablesradius[0];
3401 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3402 + fgkSSDChipCablesHeight[1])
3403 / ssdchipcablesradius[0];
3404 Double_t phi = 180.;
3405 Double_t deltaphi = 180./nedges;
3406 Double_t angle = 0.0;
3407 Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3408 Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3409 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3410 xvertexpoints[i] = new Double_t[kvertexnumber];
3411 yvertexpoints[i] = new Double_t[kvertexnumber];
3412 }
3413 TVector3* vertex = new TVector3();
3414 TVector3* transvector[kssdchipcableslaynumber];
3415 transvector[0] = new TVector3(fgkSSDChipWidth,
cd2243fb 3416 SSDChipCablesHeight-ssdchipcablesradius[0]);
bf210566 3417 transvector[1] = new TVector3();
cd2243fb 3418 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
3419 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
3420 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
bf210566 3421 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3422 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3423 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3424 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3425 transvector[1]->SetY(ssdchipcablesradius[0]
3426 + fgkSSDChipCablesHeight[0]
3427 + fgkSSDChipCablesHeight[1]);
3428 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
cd2243fb 3429 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
bf210566 3430 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
cd2243fb 3431 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
bf210566 3432 - i*fgkSSDChipCablesHeight[0]);
3433 vertexposition[i][2*(nedges+1)+2] =
3434 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3435 + fgkSSDChipCablesWidth[1]
3436 + fgkSSDChipCablesWidth[2],
3437 ((1.-i)*fgkSSDChipCablesHeight[i]
3438 + fgkSSDChipCablesHeight[1]));
3439 vertexposition[i][2*(nedges+1)+3] =
3440 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3441 vertexposition[i][2*(nedges+1)+2]->Y()
3442 - fgkSSDChipCablesHeight[i]);
3443 for(Int_t j=0; j<nedges+1; j++){
3444 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3445 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3446 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3447 vertexposition[0][(nedges+1)*i+j+2] =
3448 new TVector3(*vertex+*transvector[i]);
3449 vertexposition[1][(nedges+1)*i+j+2] =
3450 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3451 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3452 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3453 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3454 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3455 new TVector3(vertex->X()*ratio[2*i+1]
3456 + transvector[i]->X(),
3457 vertex->Y()*ratio[2*i+1]
3458 + transvector[i]->Y());
3459 }
3460 }
3461 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3462 for(Int_t j=0; j<kvertexnumber; j++){
3463 xvertexpoints[i][j] = vertexposition[i][j]->X();
3464 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3465 }
3466 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3467 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3468 xvertexpoints[i],yvertexpoints[i]);
3469 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3470 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3471 ssdchipcable[kssdchipcablesnumber*k+i] =
3472 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3473 ssdchipcableshape[kssdchipcablesnumber*k+i],
3474 (kssdchipcablesnumber*k+i)%2==0?
3475 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3476 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3477 }
3478 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3479 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3480 }
44285dfa 3481 /////////////////////////////////////////////////////////////
bf210566 3482 // Mother Volume definition
3483 /////////////////////////////////////////////////////////////
3484 Double_t ssdchipseparation = fgkSSDSensorLength
3485 - 2.*fgkSSDModuleStiffenerPosition[1]
3486 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3487 - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
cd2243fb 3488
3489 static const Int_t kmothervertexnumber = 8;
3490 Double_t xmothervertex[kmothervertexnumber];
3491 Double_t ymothervertex[kmothervertexnumber];
3492 xmothervertex[0] = xvertexpoints[0][1];
3493 ymothervertex[0] = yvertexpoints[0][1];
3494 xmothervertex[1] = xvertexpoints[0][2+nedges/2];
3495 ymothervertex[1] = yvertexpoints[0][1];
3496 xmothervertex[2] = xvertexpoints[0][2+nedges/2];
3497 ymothervertex[2] = yvertexpoints[0][2+nedges];
3498 xmothervertex[3] = xvertexpoints[0][3+nedges];
3499 ymothervertex[3] = yvertexpoints[0][3+nedges];
3500 xmothervertex[4] = xvertexpoints[0][3+2*nedges];
3501 ymothervertex[4] = yvertexpoints[0][3+2*nedges];
3502 xmothervertex[5] = xvertexpoints[0][4+2*nedges];
3503 ymothervertex[5] = yvertexpoints[0][4+2*nedges];
3504 xmothervertex[6] = xvertexpoints[1][5+2*nedges];
3505 ymothervertex[6] = yvertexpoints[1][5+2*nedges];
3506 xmothervertex[7] = xvertexpoints[0][1];
3507 ymothervertex[7] = yvertexpoints[1][5+2*nedges];
3508 TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
3509 ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3510 ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3511 ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3512
3513 TGeoVolume* ssdchipcablesmother[kssdchipcablesnumber];
3514 ssdchipcablesmother[0] = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
3515 ssdchipcablesmother[1] = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
3516
bf210566 3517 /////////////////////////////////////////////////////////////
3518 // Rotation and Translation Definition for positioning
3519 /////////////////////////////////////////////////////////////
3520 TGeoRotation* ssdchipcablesrot[5];
3521 ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
3522 ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
3523 ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
3524 ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
3525 ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
cd2243fb 3526 TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,0.,0.,ssdchipcablesrot[2]);
3527 ssdchipcablesmother[0]->AddNode(ssdchipcable[0],1);
3528 ssdchipcablesmother[0]->AddNode(ssdchipcable[1],1);
3529 ssdchipcablesmother[1]->AddNode(ssdchipcable[2],1);
3530 ssdchipcablesmother[1]->AddNode(ssdchipcable[3],1);
3531
3532 TGeoVolumeAssembly* ssdchipcablesassembly = new TGeoVolumeAssembly("SSDChipCablesAssembly");
3533 ssdchipcablesassembly->AddNode(ssdchipcablesmother[0],1,ssdchipcablesrot[4]);
3534 ssdchipcablesassembly->AddNode(ssdchipcablesmother[1],1,ssdchipcablescombitrans);
bf210566 3535 /////////////////////////////////////////////////////////////
3536 // Deallocating memory
3537 /////////////////////////////////////////////////////////////
3538 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3539 delete [] xvertexpoints[i];
3540 delete [] yvertexpoints[i];
3541 }
3542 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3543 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3544 delete vertex;
3545 delete ssdchipcablesrot[0];
3546 delete ssdchipcablesrot[1];
3547 delete ssdchipcablesrot[3];
3548 /////////////////////////////////////////////////////////////
cd2243fb 3549 return ssdchipcablesassembly;
d7599219 3550}
bf210566 3551///////////////////////////////////////////////////////////////////////////////
3552TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
3553 /////////////////////////////////////////////////////////////
3554 // SSD Chip Assembly
3555 /////////////////////////////////////////////////////////////
3556 TGeoVolume* ssdchipassembly = GetSSDChips();
3557 TList* ssdchipsystemlist = new TList();
e21cdd03 3558// const Int_t knedges = 20;
3559 const Int_t knedges = 5;
bf210566 3560 const Int_t kchipsystemnumber = 2;
5bf92139 3561
ca86fdb4 3562 TGeoVolumeAssembly* chipsystemother[kchipsystemnumber];
bf210566 3563 const char* chipsytemothername[kchipsystemnumber] =
3564 {"SSDChipSytemother1","SSDChipSytemother2"};
3565 for(Int_t i=0; i<kchipsystemnumber; i++){
ca86fdb4 3566 chipsystemother[i] = new TGeoVolumeAssembly(chipsytemothername[i]);
bf210566 3567 }
44285dfa 3568 /////////////////////////////////////////////////////////////
bf210566 3569 // SSD Chip Cables
3570 /////////////////////////////////////////////////////////////
3571 TGeoVolume* ssdchipcables[kchipsystemnumber];
3572 TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
3573 TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
3574 TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
3575 //////////////////
3576 for(Int_t i=0; i<kchipsystemnumber; i++){
3577 ssdchipcables[i] =
3578 GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
3579 ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
3580 ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
3581 ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
3582 }
3583 for(Int_t i=0; i<kchipsystemnumber; i++){
3584 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3585 ssdchipcablestrans[i][j] = new TGeoTranslation();
3586 ssdchipcablesrot[i][j] = new TGeoRotation();
3587 ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
3588 ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
3589 ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
3590 + fgkSSDChipSeparationLength),
3591 0.5*fgkSSDChipWidth,
3592 - 0.5*fgkSSDChipHeight
3593 - fgkSSDChipCablesHeight[i+2]);
3594 ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
3595 ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
3596 chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
bf210566 3597 }
3598 chipsystemother[i]->AddNode(ssdchipassembly,i+1);
e21cdd03 3599 ssdchipsystemlist->Add(chipsystemother[i]);
bf210566 3600 }
3601 /////////////////////////////////////////////////////////////
3602 // Deallocating memory
3603 /////////////////////////////////////////////////////////////
3604 for(Int_t i=0; i<kchipsystemnumber; i++){
3605 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3606 delete ssdchipcablesrot[i][j];
3607 delete ssdchipcablestrans[i][j];
3608 }
3e008bd7 3609 delete [] ssdchipcablesrot[i];
3610 delete [] ssdchipcablestrans[i];
bf210566 3611 }
3612 /////////////////////////////////////////////////////////////
3613 return ssdchipsystemlist;
d7599219 3614}
5bf92139 3615
3616//_____________________________________________________________________________
bf210566 3617TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
44285dfa 3618 /////////////////////////////////////////////////////////////
bf210566 3619 // SSD Chip Assembly Generation
3620 /////////////////////////////////////////////////////////////
3621 const Int_t kssdchiprownumber = 2;
3622 TGeoBBox* ssdchipcompshape[2];
3623 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3624 0.5*fgkSSDChipLength,
3625 0.5*fgkSSDChipWidth,
3626 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3627 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3628 0.5*fgkSSDChipLength,
3629 0.5*fgkSSDChipWidth,
3630 0.5*fgkSSDChipGlueHeight);
3631 TGeoVolume* ssdchipcomp[2];
3632 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3633 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3634 fSSDChipGlueMedium);
3635 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3636 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3637 TGeoTranslation* ssdchipcomptrans[2];
3638 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3639 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3640 /////////////////////////////////////////////////////////////
3641 // Virtual Volume containing SSDChip
3642 /////////////////////////////////////////////////////////////
3643 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3644 0.5*fgkSSDChipWidth,
3645 0.5*fgkSSDChipHeight);
e21cdd03 3646 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
bf210566 3647 /////////////////////////////////////////////////////////////
3648 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3649 Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
3650 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3651 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3652 - 0.5*fgkSSDChipWidth)};
3653 /////////////////////////////////////////////////////////////
3654 // Virtual Volume containing SSDChipAssembly
3655 /////////////////////////////////////////////////////////////
3656 TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
3657 const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
3658 Double_t xmothervertex[kssdmothervertexnumber];
3659 Double_t ymothervertex[kssdmothervertexnumber];
3660 ///////////////////////
3661 // Setting the vertices
3662 ///////////////////////
3663 xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
3664 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
3665 - ymothervertex[0];
3666 xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
3667 ymothervertex[2] = ymothervertex[1];
3668 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
3669 xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
3670 ymothervertex[4] = ymothervertex[0];
3671 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
3672 xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
3673 + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
3674 ymothervertex[6] = ymothervertex[5];
3675 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
3676 - fgkSSDChipWidth;
3677 xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3678 ymothervertex[8] = ymothervertex[7];
3679 xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3680 ymothervertex[9] = ymothervertex[6];
3681 xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
3682 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
3683 //////////////////////////////////////////////////////////
3684 ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
3685 xmothervertex,ymothervertex);
3686 ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
3687 ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
9f5fafaf 3688// TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
3689// ssdchipmothershape,fSSDAir);
3690 TGeoVolumeAssembly* ssdchipmother = new TGeoVolumeAssembly("SSDChipContainer");
bf210566 3691 /////////////////////////////////////////////////////////////
3692 for(Int_t i=0; i<kssdchiprownumber; i++)
3693 for(Int_t j=0; j<fgkSSDChipNumber; j++)
3694 ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
3695 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
3696 return ssdchipmother;
d7599219 3697}
bf210566 3698/////////////////////////////////////////////////////////////////////////////////
3699TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3700 /////////////////////////////////////////////////////////////
bf210566 3701 // Method returning a List containing pointers to Ladder Cable Volumes
cd2243fb 3702 //
3703 // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
3704 // each contains 2 volumes, one for polyamide and one for aluminium
44285dfa 3705 /////////////////////////////////////////////////////////////
bf210566 3706 const Int_t kladdercablesegmentnumber = 2;
3707 /////////////////////////////////////////
3708 // LadderSegmentBBox Volume
3709 /////////////////////////////////////////
160835d5 3710 static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
bf210566 3711 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3712 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
160835d5 3713
3714
3715 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3716 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3717 static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3718
3719 static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
3720 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3721 0.5*fgkSSDFlexWidth[0],
3722 0.5*fgkSSDLadderCableWidth,
3723 0.5*fgkSSDFlexHeight[0]),
3724 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3725 0.5*fgkSSDFlexWidth[0],
3726 0.5*fgkSSDLadderCableWidth,
3727 fgkSSDFlexHeight[0]
3728 +0.5*fgkSSDFlexHeight[1])
3729 };
3730 static TGeoVolume* laddercablesegmentbboxassembly = new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
3731 static TGeoVolume* laddercablesegmentarbassembly =
3732 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3733
3734 static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3735 static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3736
3737 if (laddercablesegmentbboxshape[0] == 0) {
3738 // Initialise static shapes and volumes
bf210566 3739 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3740 new TGeoBBox(laddercablesegmentbboxshapename[i],
3741 0.5*fgkSSDFlexWidth[0],
3742 0.5*fgkSSDLadderCableWidth,
3743 0.5*fgkSSDFlexHeight[i]);
160835d5 3744
bf210566 3745 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3746 laddercablesegmentbbox[i] =
3747 new TGeoVolume(laddercablesegmentbboxname[i],
3748 laddercablesegmentbboxshape[i],
3749 (i==0?fSSDAlTraceLadderCableMedium:
3750 fSSDKaptonLadderCableMedium));
3751 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3752 fColorPolyhamide);
3753 }
160835d5 3754
bf210566 3755 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3756 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3757 laddercablesegmentbboxtrans[i]);
3758/////////////////////////////////////////
3759// LadderSegmentArb8 Volume
3760/////////////////////////////////////////
3761 const Int_t kvertexnumber = 4;
3762 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3763 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3764 new TVector3*[kvertexnumber];
3765//Shape Vertex Positioning
3766 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3767 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3768 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3769 i*fgkSSDFlexHeight[0]);
3770 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3771 + fgkSSDFlexHeight[1]
3772 + i*fgkSSDFlexHeight[0]);
3773 laddercablesegmentvertexposition[i][3] =
3774 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3775 laddercablesegmentvertexposition[i][2]->Y());
3776 }
3777 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3778 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
a6e0ebfe 3779 const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
bf210566 3780 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
160835d5 3781
bf210566 3782 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3783 GetArbShape(laddercablesegmentvertexposition[i],
3784 laddercablesegmentwidth[i],
3785 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3786 laddercablesegmentarbshapename[i]);
3787 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3788 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
160835d5 3789
bf210566 3790 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3791 laddercablesegmentarb[i] =
3792 new TGeoVolume(laddercablesegmentarbname[i],
3793 laddercablesegmentarbshape[i],
3794 (i==0?fSSDAlTraceLadderCableMedium:
3795 fSSDKaptonLadderCableMedium));
3796 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3797 fColorPolyhamide);
d7599219 3798}
bf210566 3799 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3800 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3801 90.,90,-90.);
3802 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3803 0.,90.,0.);
3804 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3805 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3806 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3807 + fgkSSDFlexWidth[0],0.,0.,
3808 new TGeoRotation((*laddercablesegmentarbrot[1])
3809 *(*laddercablesegmentarbrot[0])));
bf210566 3810 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3811 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3812 laddercablesegmentarbcombitrans);
160835d5 3813 } // End of static initialisations
bf210566 3814/////////////////////////////////////////
3815// End Ladder Cable Volume
160835d5 3816// Note: this part depends explicitly on the length passed as an argument to the function
bf210566 3817/////////////////////////////////////////
3818 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3819 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3820 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3821 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3822 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3823 0.5*ssdendladdercablelength,
3824 0.5*fgkSSDLadderCableWidth,
3825 0.5*fgkSSDFlexHeight[i]);
3826 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3827 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3828 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3829 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3830 ladderendcablesegmentbbox[i] =
3831 new TGeoVolume(ladderendcablesegmentbboxname[i],
3832 ladderendcablesegmentbboxshape[i],
3833 (i==0?fSSDAlTraceLadderCableMedium:
3834 fSSDKaptonLadderCableMedium));
3835 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3836 fColorPolyhamide);
3837 }
3838 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3839 ladderendcablesegmentbboxtrans[0] =
3840 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
3841 0.5*ssdendladdercablelength,
3842 0.5*fgkSSDLadderCableWidth,
3843 0.5*fgkSSDFlexHeight[0]);
3844 ladderendcablesegmentbboxtrans[1] =
3845 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
3846 0.5*ssdendladdercablelength,
3847 0.5*fgkSSDLadderCableWidth,
3848 fgkSSDFlexHeight[0]
3849 +0.5*fgkSSDFlexHeight[1]);
3850 TGeoVolume* ladderendcablesegmentbboxassembly =
3851 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
3852 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3853 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
3854 ladderendcablesegmentbboxtrans[i]);
3855/////////////////////////////////////////
3856 TList* laddercablesegmentlist = new TList();
3857 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
3858 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
3859 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
3860 return laddercablesegmentlist;
160835d5 3861}
3862
bf210566 3863/////////////////////////////////////////////////////////////////////////////////
3864TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 3865 /////////////////////////////////////////////////////////////
cd2243fb 3866 // Method generating Ladder Cable of given length (n modules + end)
3867 // Called by GetLadderCableAssembly
44285dfa 3868 /////////////////////////////////////////////////////////////
bf210566 3869 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
3870 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
3871 for(Int_t i=0; i<n; i++){
3872 TGeoTranslation* laddercabletrans = new TGeoTranslation(
3873 i*(fgkCarbonFiberJunctionWidth),
3874 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3875 i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
3876 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
cd2243fb 3877 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
3878
d7599219 3879 }
bf210566 3880 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
3881 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
cd2243fb 3882 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
3883 (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
bf210566 3884 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
3885 return laddercable;
3886}
3887/////////////////////////////////////////////////////////////////////////////////
3888TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
cd2243fb 3889 ///////////////////////////////////////////////////////////////////
3890 // Main method generating Ladder Cable bundles containing n cables
3891 ///////////////////////////////////////////////////////////////////
3892 Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
3893 Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1])};
3894 TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]),cableOrig);
3895 TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
a3f8715e 3896 char laddercabletransname[100];
bf210566 3897 for(Int_t i=0; i<n; i++){
3898 sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
cd2243fb 3899 laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
3900 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
d7599219 3901 }
cd2243fb 3902 return laddercable;
bf210566 3903}
3904/////////////////////////////////////////////////////////////////////////////////
3905TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
3906 /////////////////////////////////////////////////////////////
3907 // Method generating Ladder Cable List Assemblies
cd2243fb 3908 // containing two cables bundles, i.e. P+N readout for one endcap
bf210566 3909 /////////////////////////////////////////////////////////////
cd2243fb 3910 const Int_t kladdercableassemblynumber = 2;
bf210566 3911 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
3912 TGeoVolume* ladderCable[kladdercableassemblynumber];
a3f8715e 3913 char laddercableassemblyname[100];
bf210566 3914 TList* laddercableassemblylist = new TList();
3915 for(Int_t i=0; i<kladdercableassemblynumber; i++){
3916 sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
3917 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
3918 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
3919 new TGeoCombiTrans((n-1)
3920 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3921 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
3922 0.,new TGeoRotation("",180,0.,0.)));
3923 laddercableassemblylist->Add(ladderCable[i]);
3924}
3925 return laddercableassemblylist;
3926}
3927///////////////////////////////////////////////////////////////////////////////
3928void AliITSv11GeometrySSD::SetLadderSegment(){
3929 /////////////////////////////////////////////////////////////
3930 // Method Generating Ladder Segment Array
3931 /////////////////////////////////////////////////////////////
3932 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
3933 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
cd2243fb 3934
3935 /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
3936 TGeoXtru *laddersegmentshape = new TGeoXtru(2);
3937 static const Int_t ntrianglevtx = 3;
3938 Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
3939 Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
3940 laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
3941 laddersegmentshape->DefineSection(0,0);
3942 laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth); // MVL
3943 fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
3944 fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
3945 */
3946
bf210566 3947 if(!fCreateMaterials) CreateMaterials();
3948 if(!fTransformationMatrices) CreateTransformationMatrices();
3949 if(!fBasicObjects) CreateBasicObjects();
3950 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
3951 // Placing Carbon Fiber Support
3952 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
3953 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3954 fcarbonfibersupportmatrix[j]);
3955 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3956 fcarbonfibersupportmatrix[j]);
d7599219 3957 }
bf210566 3958 // Placing Carbon Fiber Junction
cd2243fb 3959 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
bf210566 3960 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
3961 fcarbonfiberjunctionmatrix[j]);
cd2243fb 3962 }
bf210566 3963 // Placing Carbon Fiber Lower Support
cd2243fb 3964 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
bf210566 3965 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
3966 fcarbonfiberlowersupportrans[j]);
cd2243fb 3967 }
bf210566 3968 // Placing SSD Sensor Support
3969 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
cd2243fb 3970 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
bf210566 3971 fssdsensorsupport[1][i],
3972 j+1,fssdsensorsupportmatrix[j]);
3973 // Placing SSD Cooling Tube Support
3974 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
3975 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3976 fcoolingtubesupportmatrix[j]);
3977 // Placing SSD Cooling Tube
cd2243fb 3978 fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
3979 fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
bf210566 3980 // Placing SSD Hybrid
3981 switch(i){
3982 case 0:
3983 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
3984 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3985 break;
3986 case 1:
3987 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
3988 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3989 break;
3990 }
3991 // Placing Cooling Block System
cd2243fb 3992 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
bf210566 3993 // Placing SSD Flex
cd2243fb 3994 for(Int_t j=0; j<fgkflexnumber; j++){
3995 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
3996 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
3997 }
bf210566 3998 }
d7599219 3999}
bf210566 4000///////////////////////////////////////////////////////////////////////////////
4001void AliITSv11GeometrySSD::SetEndLadderSegment(){
4002 /////////////////////////////////////////////////////////////
4003 // Method Generating End Ladder
4004 /////////////////////////////////////////////////////////////
4005 // End Ladder Carbon Fiber Junction
4006 /////////////////////////////////////////////////////////////
4007 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
4008 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
4009 if(!fCreateMaterials) CreateMaterials();
4010 if(!fTransformationMatrices) CreateTransformationMatrices();
4011 if(!fBasicObjects) CreateBasicObjects();
4012 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
4013 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
4014 fendladdersegment[i]->AddNode(j==2 ?
4015 fendladdercarbonfiberjunction[i][1] :
4016 fendladdercarbonfiberjunction[i][0],
4017 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
4018 }
4019 /////////////////////////////////////////////////////////////
4020 // End Ladder Carbon Fiber Support
4021 /////////////////////////////////////////////////////////////
4022 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
4023 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
4024 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4025 fendladdercarbonfibermatrix[i][j]);
4026 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4027 fendladdercarbonfibermatrix[i][j]);
4028 }
4029 /////////////////////////////////////////////////////////////
4030 // End Ladder Mounting Block
4031 /////////////////////////////////////////////////////////////
9b0c60ab 4032 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4033 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
e21cdd03 4034 fendladdermountingblockcombitrans[i]);
9b0c60ab 4035 /////////////////////////////////////////////////////////////
e5bf64ae 4036 // End Ladder Mounting Block Clip
9b0c60ab 4037 /////////////////////////////////////////////////////////////
4038 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4039 for(Int_t j=0; j<2; j++)
e21cdd03 4040 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
4041 fendladdermountingblockclipmatrix[i][j]);
bf210566 4042 /////////////////////////////////////////////////////////////
4043 // End Ladder Lower Supports
44285dfa 4044 /////////////////////////////////////////////////////////////
bf210566 4045 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
e21cdd03 4046 fendladderlowersupptrans[0]);
bf210566 4047 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
e21cdd03 4048 fendladderlowersupptrans[1]);
bf210566 4049 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
e21cdd03 4050 fendladderlowersupptrans[2]);
9b0c60ab 4051 /////////////////////////////////////////////////////////////
4052 // End Ladder Cooling Tube Support
4053 /////////////////////////////////////////////////////////////
4054 for(Int_t i=0; i<2; i++)
4055 for(Int_t j=0; j<(i==0?4:2); j++)
e21cdd03 4056 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4057 fendladdercoolingtubesupportmatrix[i][j]);
9b0c60ab 4058 /////////////////////////////////////////////////////////////
4059 // End Ladder Cooling Tube Support
4060 /////////////////////////////////////////////////////////////
cd2243fb 4061 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
4062 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
4063 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
4064 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
bf210566 4065}
4066///////////////////////////////////////////////////////////////////////////////
4067void AliITSv11GeometrySSD::SetLadder(){
4068 /////////////////////////////////////////////////////////////
4069 // Method Generating Ladder of Layer 5 and 6
44285dfa 4070 /////////////////////////////////////////////////////////////
bf210566 4071 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
4072 fgkSSDLay6SensorsNumber};
4073 /////////////////////////////////////////////////////////////////////////////
4074 /// Generating Ladder Mother Volume Containing Ladder
4075 /////////////////////////////////////////////////////////////////////////////
4076 TGeoXtru* laddershape[fgkladdernumber];
4077 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
4078 const Int_t kmothervertexnumber = 8;
4079 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
4080 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
4081 ///////////////////////
4082 // Setting the vertices
4083 ///////////////////////
4084 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
4085 * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
4086 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
0fb26117 4087 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
bf210566 4088 xmothervertex[0][1] = xmothervertex[0][0];
4089 ymothervertex[0][1] = 0.0;
4090 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
4091 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
4092 ymothervertex[0][2] = ymothervertex[0][1];
4093 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
4094 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
4095 xmothervertex[0][4] = -xmothervertex[0][3];
4096 ymothervertex[0][4] = ymothervertex[0][3];
4097 xmothervertex[0][5] = -xmothervertex[0][2];
4098 ymothervertex[0][5] = ymothervertex[0][2];
4099 xmothervertex[0][6] = -xmothervertex[0][1];
4100 ymothervertex[0][6] = ymothervertex[0][1];
4101 xmothervertex[0][7] = -xmothervertex[0][0];
4102 ymothervertex[0][7] = ymothervertex[0][0];
4103 for(Int_t i=0; i<kmothervertexnumber; i++){
4104 xmothervertex[1][i] = xmothervertex[0][i];
4105 ymothervertex[1][i] = ymothervertex[0][i];
4106 }
0fb26117 4107///////////////////////////////////////////////////////////////////////////
4108// Disalignement Mother Volume corrections 25/08/08
4109///////////////////////////////////////////////////////////////////////////
160835d5 4110 TGeoXtru* leftladdershape1[fgkladdernumber];
4111 TGeoXtru* leftladdershape2[fgkladdernumber];
0fb26117 4112 TGeoXtru* centersensorladdershape[fgkladdernumber];
160835d5 4113 TGeoXtru* rightladdershape1[fgkladdernumber];
4114 TGeoXtru* rightladdershape2[fgkladdernumber];
bf210566 4115 for(Int_t i=0; i<fgkladdernumber; i++){
160835d5 4116 leftladdershape1[i] = new TGeoXtru(2);
4117 leftladdershape2[i] = new TGeoXtru(2);
4118 centersensorladdershape[i] = new TGeoXtru(2);
4119 rightladdershape1[i] = new TGeoXtru(2);
4120 rightladdershape2[i] = new TGeoXtru(2);
4121 }
0fb26117 4122 //////////////////////////////////////
160835d5 4123 // Setting the names for shapes
0fb26117 4124 //////////////////////////////////////
160835d5 4125 leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
4126 leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
4127 leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
4128 leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
0fb26117 4129 centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
4130 centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
160835d5 4131 rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
4132 rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
4133 rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
4134 rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
0fb26117 4135 //////////////////////////////////////
160835d5 4136 Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
4137 Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
0fb26117 4138 Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
4139 Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
160835d5 4140 Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
4141 Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
4142 for(Int_t i=0; i<fgkladdernumber; i++) {
4143 for(Int_t j=0; j<kmothervertexnumber; j++){
4144 xcentersensorvertex[i][j] = xmothervertex[i][j];
4145 ycentersensorvertex[i][j] = ymothervertex[i][j];
4146 xend1laddervertex[i][j] = xmothervertex[i][j];
4147 yend1laddervertex[i][j] = ymothervertex[i][j];
4148 xend2laddervertex[i][j] = xmothervertex[i][j];
4149 yend2laddervertex[i][j] = ymothervertex[i][j];
4150 }
4151 // Add some space around sensors to accommodate misalignments
4152 xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
4153 xcentersensorvertex[i][1] = xcentersensorvertex[0][0];
4154 xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
4155 xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
4156
4157 ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
4158 ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
4159
4160 // Center Ladder Piece
4161 centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
4162 ycentersensorvertex[i]);
4163 centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
4164 + 1.45*fgkSSDMountingBlockWidth);
4165 centersensorladdershape[i]->DefineSection(1, ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
4166 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4167 - 2.4*fgkSSDMountingBlockWidth);
0fb26117 4168
160835d5 4169 // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
0fb26117 4170
160835d5 4171 // Cuts off first corner (neg x)
4172 xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4173 xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
4174 // Cuts off last part (pos x)
4175 xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
4176 xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
0fb26117 4177
160835d5 4178 leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4179 yend1laddervertex[i]);
4180 leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4181 leftladdershape1[i]->DefineSection(1, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4182 - fgkEndLadderMountingBlockPosition[0]);
4183
4184 leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4185 yend2laddervertex[i]);
4186 leftladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4187 - fgkEndLadderMountingBlockPosition[0]);
4188 leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
4189 + 1.45*fgkSSDMountingBlockWidth); // connect to main volume at -1.6725 cm
4190
4191 rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4192 yend1laddervertex[i]);
4193 rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4194 +fgkEndLadderCarbonFiberLowerJunctionLength[0]
4195 -2.4*fgkSSDMountingBlockWidth);
4196 rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4197 + fgkEndLadderMountingBlockPosition[1]);
4198
4199 rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4200 yend2laddervertex[i]);
4201 rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4202 + fgkEndLadderMountingBlockPosition[1]);
4203 rightladdershape2[i]->DefineSection(1, ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4204 + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4205 }
4206 TGeoCompositeShape* laddershapecontainer[2];
4207 laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4208 "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4209 "+Lay5CenterSensorContainer"
4210 "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4211 laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4212 "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4213 "+Lay6CenterSensorContainer"
4214 "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4215 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4216 for(Int_t i=0; i<fgkladdernumber; i++){
4217 fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4218 fladder[i]->SetLineColor(4);
4219 }
bf210566 4220///////////////////////////////////////////////////////////////////////////
4221 if(!fCreateMaterials) CreateMaterials();
4222 if(!fTransformationMatrices) CreateTransformationMatrices();
4223 if(!fBasicObjects) CreateBasicObjects();
4224 SetLadderSegment();
4225 SetEndLadderSegment();
4226 for(Int_t i=0; i<fgkladdernumber; i++){
4227 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4228 //////////////////////////
4229 /// Placing Ladder Segment
4230 //////////////////////////
4231 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4232 fladdersegment[i==0 ? 1 : 0],
4233 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4234 //////////////////////////
4235 /// Placing SSD Sensor
4236 //////////////////////////
ca86fdb4 4237 if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
bf210566 4238 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4239 fssdsensormatrix[i][j]);
4240 }
4241 ///////////////////////////////
4242 /// Placing End Ladder Segment
4243 ///////////////////////////////
160835d5 4244 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
bf210566 4245 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4246 }
d7599219 4247/////////////////////////////////////////////////////////////////////////////
4248/// Placing Ladder Cables
4249/////////////////////////////////////////////////////////////////////////////
bf210566 4250 Int_t sidecablenumber[2][2];
4251 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4252 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4253 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4254 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4255 Double_t carbonfibertomoduleposition[3];
4256 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4257 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4258 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4259 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4260 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4261 - fgkSSDSensorCenterSupportThickness[0]);
4262 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4263 + 0.5*fgkCoolingTubeSupportHeight
4264 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4265 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4266 Double_t ssdendladdercablelength[4];
4267 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4268 + fgkSSDSensorLength
4269 - fgkSSDModuleStiffenerPosition[1]
4270 - fgkSSDStiffenerWidth
4271 - fgkSSDFlexWidth[0]
bf210566 4272 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4273 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4274 + fgkSSDModuleStiffenerPosition[1]
4275 + fgkSSDStiffenerWidth
bf210566 4276 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4277 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4278 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4279 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4280 - kendladdercablecorrection;
44285dfa 4281 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4282 + carbonfibertomoduleposition[1]
d7599219 4283 - fgkSSDModuleStiffenerPosition[1]
4284 - fgkSSDStiffenerWidth)
bf210566 4285 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
44285dfa 4286 TList* laddercableassemblylist[4];
4287 const Int_t kendladdercablesnumber = 4;
cd2243fb 4288 TGeoRotation *laddercablerot = new TGeoRotation();
4289 laddercablerot->SetAngles(90.,60.,-90.);
bf210566 4290 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4291 for(Int_t j=0; j<kendladdercablesnumber; j++){
4292 laddercableassemblylist[j] =
4293 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4294 ssdendladdercablelength[j]);
0fb26117 4295 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4296 j<2?1:2,fladdercablematrix[i][j]);
bf210566 4297 }
bf210566 4298}
4299////////////////////////////////////////////////////////////////////////////////
4300void AliITSv11GeometrySSD::SetLayer(){
d7599219 4301////////////////////////////////////////////////////////////////////////////////
bf210566 4302 // Creating Ladder of Layer 5 and Layer 6
4303 /////////////////////////////////////////////////////////////
4304 if(!fCreateMaterials) CreateMaterials();
4305 if(!fTransformationMatrices) CreateTransformationMatrices();
4306 if(!fBasicObjects) CreateBasicObjects();
4307 SetLadder(); // Generating the ladder of Layer5 and Layer6
4308 const Int_t kssdlayladdernumber[fgklayernumber] =
4309 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4310 /////////////////////////////////////////////////////////////
4311 // Generating mother volumes for Layer5 and Layer6
4312 /////////////////////////////////////////////////////////////
e5bf64ae 4313 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4314 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
bf210566 4315 Int_t *ladderindex[fgklayernumber];
4316 Int_t index[fgklayernumber] = {8,9};
4317 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4318 for(Int_t i=0; i<fgklayernumber; i++)
4319 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4320 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4321 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4322 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4323 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4324 }
44285dfa 4325 /////////////////////////////////////////////////////////////
bf210566 4326 // Deallocating memory
4327 /////////////////////////////////////////////////////////////
7b208ef4 4328 for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
d7599219 4329}
4330////////////////////////////////////////////////////////////////////////////////
4331void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4332 /////////////////////////////////////////////////////////////
4333 // Insert the layer 5 in the mother volume.
4334 /////////////////////////////////////////////////////////////
4335 if (! moth) {
160835d5 4336 AliError("Can't insert layer5, mother is null!\n");
44285dfa 4337 return;
4338 };
bf210566 4339 if(!fSSDLayer5) SetLayer();
4340 fMotherVol = moth;
4341 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4342 + fgkLay5CenterITSPosition);
4343 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4344 }
d7599219 4345////////////////////////////////////////////////////////////////////////////////
4346void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4347 /////////////////////////////////////////////////////////////
4348 // Insert the layer 6 in the mother volume.
4349 /////////////////////////////////////////////////////////////
4350 if (! moth) {
160835d5 4351 AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
44285dfa 4352 return;
4353 };
bf210566 4354 if(!fSSDLayer6) SetLayer();
4355 fMotherVol = moth;
4356 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4357 + fgkLay6CenterITSPosition);
4358 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4359 }
bf210566 4360 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4361 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4362 /////////////////////////////////////////////////////////////
4363 // Method generating the Arc structure of Ladder Support
4364 /////////////////////////////////////////////////////////////
4365 const Int_t kssdlayladdernumber[fgklayernumber] =
4366 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4367 Double_t mountingsupportedge[fgklayernumber];
4368 Double_t mountingblockratio[fgklayernumber];
4369 Double_t theta[fgklayernumber];
4370 Double_t phi[fgklayernumber];
4371 Double_t psi0[fgklayernumber];
4372 Double_t deltapsi[fgklayernumber];
4373 TVector3* mountingsupportedgevector[fgklayernumber];
4374 for(Int_t i=0; i<fgklayernumber; i++){
4375 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4376 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4377 * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4378 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4379 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4380 / kssdlayladdernumber[i])));
4381 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4382 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4383 mountingsupportedgevector[i] = new TVector3();
60e55aee 4384 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4385 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4386 (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4387 (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
9b0c60ab 4388 psi0[i] = 0.5*TMath::Pi()-phi[i];
4389 deltapsi[i] = (theta[i]+phi[i])/nedges;
4390 }
4391 TVector3** vertex[fgklayernumber];
4392 TList* vertexlist[fgklayernumber];
4393 Int_t indexedge[fgklayernumber] = {0,0};
4394 for(Int_t i=0; i<fgklayernumber; i++){
4395 vertex[i] = new TVector3*[nedges+1];
4396 vertexlist[i] = new TList();
4397 }
4398 for(Int_t i=0; i<fgklayernumber; i++){
4399 for(Int_t j=0; j<nedges+1; j++){
4400 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4401 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4402 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4403 vertexlist[i]->Add(vertex[i][j]);
4404 }
4405 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4406 }
4407 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4408 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4409 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4410 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4411 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4412 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4413 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4414 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4415 for(Int_t i=0; i<fgklayernumber; i++){
4416 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4417 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4418 xcentervertex[i] = new Double_t[indexedge[i]+3];
4419 ycentervertex[i] = new Double_t[indexedge[i]+3];
4420 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4421 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4422 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4423 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4424 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4425 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4426 ((TVector3*)vertexlist[i]->At(j))->X();
4427 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4428 ((TVector3*)vertexlist[i]->At(j))->Y();
4429 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4430 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4431 if(j<indexedge[i]+1){
4432 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4433 ((TVector3*)vertexlist[i]->At(j))->X();
4434 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4435 ((TVector3*)vertexlist[i]->At(j))->Y();
4436 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4437 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4438 }
4439 }
4440 xsidevertex[i][1] = xsidevertex[i][0];
4441 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4442 xsidevertex[i][2] = xsidevertex[i][3];
4443 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4444 xcentervertex[i][1] = xcentervertex[i][0];
4445 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4446 xcentervertex[i][2] = xcentervertex[i][3];
4447 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4448 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4449 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4450 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4451 ycenterlowervertex[i][0] = ysidevertex[i][0];
4452 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4453 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4454 }
4455 /////////////////////////////////////////////////////////////
4456 // Building the Arc Structure of Ladder Supports
4457 /////////////////////////////////////////////////////////////
4458 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4459 TGeoXtru* centermountingsupportshape[fgklayernumber];
4460 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4461 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4462 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4463 TGeoVolume* centermountingblocksupport[fgklayernumber];
4464 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4465 TGeoVolume* centerladdersupportpiece[fgklayernumber];
a3f8715e 4466 char sidemountingblockname[100];
4467 char centermountingblockname[100];
4468 char sideladdersupportpiecename[100];
4469 char centerladdersupportpiecename[100];
9b0c60ab 4470 for(Int_t i=0; i<fgklayernumber; i++){
4471 sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4472 sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4473 sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4474 sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4475 sidemountingblocksupportshape[i] = new TGeoXtru(2);
4476 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4477 xsidevertex[i],ysidevertex[i]);
4478 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4479 -fgkMountingBlockSupportWidth[0]);
4480 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4481 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4482 sidemountingblocksupportshape[i],
4483 fSSDAlCoolBlockMedium);
4484 sidemountingblocksupport[i]->SetLineColor(9);
4485 centermountingsupportshape[i] = new TGeoXtru(2);
4486 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4487 xcentervertex[i],ycentervertex[i]);
4488 centermountingsupportshape[i]->DefineSection(0,0.);
4489 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4490 -fgkMountingBlockSupportWidth[0]);
160835d5 4491
9b0c60ab 4492 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4493 centermountingsupportshape[i],
4494 fSSDAlCoolBlockMedium);
4495 centermountingblocksupport[i]->SetLineColor(9);
4496 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4497 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4498 xsidelowervertex[i],ysidelowervertex[i]);
4499 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4500 -fgkMountingBlockSupportWidth[0]);
4501 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4502 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4503 sideladdersupportpieceshape[i],
e21cdd03 4504 fSSDCarbonFiberMedium);
9b0c60ab 4505 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4506 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4507 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4508 xcenterlowervertex[i],ycenterlowervertex[i]);
4509 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4510 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4511 -fgkMountingBlockSupportWidth[0]);
4512 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4513 centerladdersupportpieceshape[i],
e21cdd03 4514 fSSDCarbonFiberMedium);
9b0c60ab 4515 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4516 }
4517 /////////////////////////////////////////////////////////////
4518 // Building the Up Structure of Ladder Supports
4519 /////////////////////////////////////////////////////////////
4520 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4521 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4522 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4523 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4524 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4525 //////////////////////////////////////////////////////////
4526 // Setting the volume for TGeoXtru Mounting Block Piece
4527 //////////////////////////////////////////////////////////
4528 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4529 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4530 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4531 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4532 TGeoVolume* mountingblockpieceup[fgklayernumber];
4533 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4534 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4535 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4536 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
a3f8715e 4537 char mountingblockpiecedownname[100];
4538 char mountingblockpieceupname[100];
9b0c60ab 4539 for(Int_t i=0; i<fgklayernumber; i++){
4540 ///////////////////////////
4541 // Mounting Block Down Vertex
4542 ///////////////////////////
4543 mountingblockpiecedownshape[i] = new TGeoXtru(2);
4544 sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4545 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4546 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4547 + fgkMountingBlockSupportDownHeight
4548 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4549 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4550 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4551 + fgkSSDMountingBlockHeight[1]
4552 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4553 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4554 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4555 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4556 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4557 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4558 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4559 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4560 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4561 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4562 + fgkSSDMountingBlockHeight[2]
4563 - fgkSSDMountingBlockHeight[0];
4564 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4565 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4566 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4567 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4568 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4569 mountingblockpiecedownyvertex[i]);
4570 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4571 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4572 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
e21cdd03 4573 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
9b0c60ab 4574 mountingblockpiecedown[i]->SetLineColor(fColorG10);
160835d5 4575
9b0c60ab 4576 ///////////////////////////
4577 // Mounting Block Up Vertex
4578 ///////////////////////////
4579 mountingblockpieceupshape[i] = new TGeoXtru(2);
4580 sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4581 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4582 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4583 + fgkMountingBlockSupportUpHeight[i]
4584 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4585 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4586 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4587 + fgkSSDMountingBlockHeight[1]
4588 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4589 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4590 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4591 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4592 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4593 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4594 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4595 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4596 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4597 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4598 + fgkSSDMountingBlockHeight[2]
4599 - fgkSSDMountingBlockHeight[0];
4600 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4601 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4602 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4603 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
160835d5 4604
9b0c60ab 4605 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4606 mountingblockpieceupyvertex[i]);
4607 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4608 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4609 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
e21cdd03 4610 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
9b0c60ab 4611 mountingblockpieceup[i]->SetLineColor(fColorG10);
4612 }
4613 ///////////////////////////////////////////////////////////////////
4614 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4615 ///////////////////////////////////////////////////////////////////
4616 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4617 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4618 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4619 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4620 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4621 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4622 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4623 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
a3f8715e 4624 char mountingblocksupportrapezoidowname[100];
4625 char mountingblocksupportrapezoidupname[100];
9b0c60ab 4626 Double_t scalefactor = 3./4.;
4627 for(Int_t i=0; i<fgklayernumber; i++){
4628 ////////////////////////////////////////////
4629 // Mounting Block Support Down Trapezoid Vertex
4630 ////////////////////////////////////////////
4631 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4632 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4633 - mountingsupportedge[i];
4634 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4635 mountingblocksupportrapezoidownxvertex[i][1] =
4636 mountingblocksupportrapezoidownxvertex[i][0];
4637 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4638 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4639 - mountingblockpiecedownyvertex[i][0]);
4640 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4641 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4642 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4643 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4644 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4645 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
160835d5 4646
9b0c60ab 4647 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4648 mountingblocksupportrapezoidownyvertex[i]);
4649 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4650 -fgkMountingBlockSupportWidth[0]);
4651 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4652 sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4653 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
e21cdd03 4654 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4655 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4656 ////////////////////////////////////////////
4657 // Mounting Block Support Up Trapezoid Vertex
4658 ////////////////////////////////////////////
4659 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4660 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4661 - mountingsupportedge[i];
4662 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4663 mountingblocksupportrapezoidupxvertex[i][1] =
4664 mountingblocksupportrapezoidupxvertex[i][0];
4665 mountingblocksupportrapezoidupyvertex[i][1] =
4666 mountingblockpieceupyvertex[i][0]
4667 + scalefactor*(mountingblockpieceupyvertex[i][1]
4668 - mountingblockpieceupyvertex[i][0]);
4669 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4670 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4671 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4672 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4673 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4674 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
160835d5 4675
9b0c60ab 4676 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4677 mountingblocksupportrapezoidupyvertex[i]);
4678 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4679 -fgkMountingBlockSupportWidth[0]);
4680 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4681 sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4682 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
e21cdd03 4683 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4684 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4685 }
4686 ///////////////////////////////////////////////////////////////////
4687 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4688 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4689 Double_t boxoriginup[fgklayernumber][2][3];
4690 Double_t boxorigindown[fgklayernumber][2][3];
a3f8715e 4691 char mountingblocksupportboxdownname[100];
4692 char mountingblocksupportboxupname[100];
9b0c60ab 4693 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4694 mountingblocksupportrot->SetAngles(90.,180.,-90);
4695 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4696 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4697 TGeoHMatrix* laddersupportmatrix[2];
4698 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4699 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4700 /////////////////////////////////////////////////////////////
4701 // Creating Mother Volume for Containment
4702 /////////////////////////////////////////////////////////////
4703 Double_t *xmothervertex[fgklayernumber];
4704 Double_t *ymothervertex[fgklayernumber];
4705 for(Int_t i=0; i<fgklayernumber; i++){
4706 xmothervertex[i] = new Double_t[8];
4707 ymothervertex[i] = new Double_t[8];
4708 }
4709 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4710 TGeoVolume* downmotherladdersupport[fgklayernumber];
4711 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
160835d5 4712 TGeoVolume* upmotherladdersupport[fgklayernumber];
a3f8715e 4713 char upmotheladdersupportname[100];
4714 char downmotheladdersupportname[100];
9b0c60ab 4715 for(Int_t i=0; i<fgklayernumber; i++){
4716 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4717 - mountingsupportedge[i];
4718 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4719 xmothervertex[i][1] = xmothervertex[i][0];
4720 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4721 + fgkMountingBlockSupportWidth[0];
4722 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4723 ymothervertex[i][2] = ymothervertex[i][1];
4724 xmothervertex[i][3] = xmothervertex[i][2];
4725 ymothervertex[i][3] = -ymothervertex[i][0];
4726 xmothervertex[i][4] = -xmothervertex[i][0];
4727 ymothervertex[i][4] = ymothervertex[i][3];
4728 xmothervertex[i][5] = xmothervertex[i][4];
4729 ymothervertex[i][5] = -ymothervertex[i][1];
4730 xmothervertex[i][6] = -xmothervertex[i][2];
4731 ymothervertex[i][6] = ymothervertex[i][5];
4732 xmothervertex[i][7] = xmothervertex[i][6];
4733 ymothervertex[i][7] = ymothervertex[i][0];
160835d5 4734
9b0c60ab 4735 sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4736 sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
160835d5 4737
4738 downmotherladdersupportshape[i] = new TGeoXtru(2);
9b0c60ab 4739 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4740 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
160835d5 4741 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
9b0c60ab 4742 + fgkMountingBlockSupportDownHeight
4743 + fgkSSDMountingBlockHeight[1]
4744 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4745 - fgkSSDModuleCoolingBlockToSensor
4746 - fgkSSDLadderVerticalDisalignment);
4747
4748// - fgkSSDModuleVerticalDisalignment);
4749 //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4750
4751 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4752 downmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4753 upmotherladdersupportshape[i] = new TGeoXtru(2);
4754 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4755 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4756 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4757 + fgkMountingBlockSupportUpHeight[i]
4758 + fgkSSDMountingBlockHeight[1]
4759 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4760 - fgkSSDModuleCoolingBlockToSensor
4761 - fgkSSDLadderVerticalDisalignment);
4762
4763 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4764 upmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4765 }
4766 for(Int_t i=0; i<fgklayernumber; i++){
4767 /////////////////////////
4768 // Setting the box origin
4769 /////////////////////////
4770 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4771 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4772 + 0.5*fgkMountingBlockSupportDownHeight
4773 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4774 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4775 - 0.5*fgkMountingBlockSupportWidth[0];
4776
4777 boxorigindown[i][1][0] = 0.0;
4778 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4779 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4780 - fgkMountingBlockSupportWidth[0]);
4781
4782 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4783 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4784 + 0.5*fgkMountingBlockSupportUpHeight[i]
4785 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4786 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4787 - 0.5*fgkMountingBlockSupportWidth[0];
4788
4789 boxoriginup[i][1][0] = 0.0;
160835d5 4790 boxoriginup[i][1][1] = boxoriginup[i][0][1];
9b0c60ab 4791 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4792 - fgkMountingBlockSupportWidth[0]);
4793
4794 /////////////////////////
4795 // Setting the boxes
4796 /////////////////////////
4797 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4798 + fgkSSDMountingBlockLength[0]),
160835d5 4799 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4800 0.5*fgkMountingBlockSupportWidth[0],
4801 boxorigindown[i][0]);
160835d5 4802 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4803 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4804 0.5*(fgkMountingBlockSupportWidth[1]
4805 - fgkMountingBlockSupportWidth[0]),
4806 boxorigindown[i][1]);
4807
4808 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4809 + fgkSSDMountingBlockLength[0]),
160835d5 4810 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4811 0.5*fgkMountingBlockSupportWidth[0],
4812 boxoriginup[i][0]);
160835d5 4813
9b0c60ab 4814 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
160835d5 4815 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4816 0.5*(fgkMountingBlockSupportWidth[1]
4817 - fgkMountingBlockSupportWidth[0]),
4818 boxoriginup[i][1]);
4819 ///////////////////////////////////////
160835d5 4820 // Adding the Volumes to Mother Volume
9b0c60ab 4821 ///////////////////////////////////////
4822 for(Int_t j=0; j<2; j++){
4823 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4824 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4825 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4826 mountingblocksupportboxdownshape[i][j],
e21cdd03 4827 fSSDCarbonFiberMedium);
9b0c60ab 4828 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4829 mountingblocksupportboxupshape[i][j],
e21cdd03 4830 fSSDCarbonFiberMedium);
9b0c60ab 4831 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4832 mountingblocksupportboxup[i][j]->SetLineColor(9);
4833 for(Int_t k=0; k<2; k++){
4834 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
160835d5 4835 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
9b0c60ab 4836 }
4837 }
4838 for(Int_t k=0; k<2; k++){
4839 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4840 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4841 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4842 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
160835d5 4843 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4844 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4845 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
160835d5 4846 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4847 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4848 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4849 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4850 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4851 }
4852 }
4853 TList* laddersupportlist = new TList();
4854 laddersupportlist->Add(downmotherladdersupport[0]);
4855 laddersupportlist->Add(upmotherladdersupport[0]);
4856 laddersupportlist->Add(downmotherladdersupport[1]);
4857 laddersupportlist->Add(upmotherladdersupport[1]);
4858 /////////////////////////////////////////////////////////////
4859 // Deallocating memory
4860 /////////////////////////////////////////////////////////////
4861 for(Int_t i=0; i<fgklayernumber; i++){
4862 for(Int_t j=0; j<nedges+1; j++)
4863 delete vertex[i][j];
4864 delete mountingsupportedgevector[i];
4865 delete [] vertex[i];
4866 delete vertexlist[i];
4867 delete [] xsidevertex[i];
4868 delete [] ysidevertex[i];
4869 delete [] xcentervertex[i];
4870 delete [] ycentervertex[i];
4871 delete [] xsidelowervertex[i];
4872 delete [] ysidelowervertex[i];
4873 delete [] xcenterlowervertex[i];
4874 delete [] ycenterlowervertex[i];
7b208ef4 4875 delete [] xmothervertex[i];
4876 delete [] ymothervertex[i];
9b0c60ab 4877 }
3e008bd7 4878 delete [] xsidevertex;
4879 delete [] ysidevertex;
4880 delete [] xcentervertex;
4881 delete [] ycentervertex;
4882 delete [] xsidelowervertex;
4883 delete [] ysidelowervertex;
4884 delete [] xcenterlowervertex;
4885 delete [] ycenterlowervertex;
9b0c60ab 4886 delete globalrefladdersupportrot;
4887 delete mountingblocksupportrot;
4888 /////////////////////
4889 return laddersupportlist;
4890}
4891 ////////////////////////////////////////////////////////////////////////////////
4892void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4893//////////////////////////////////////////
4894// Method Generating Ladder Support Ring
4895//////////////////////////////////////////
4896 if(!fCreateMaterials) CreateMaterials();
4897 if(!fTransformationMatrices) CreateTransformationMatrices();
4898 if(!fBasicObjects) CreateBasicObjects();
4899 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4900 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4901 const Int_t kssdlayladdernumber[fgklayernumber] =
4902 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4903 Double_t mountingsupportedge[fgklayernumber];
4904 Double_t mountingblockratio[fgklayernumber];
4905 Double_t theta[fgklayernumber];
4906 Double_t phi[fgklayernumber];
4907 for(Int_t i=0; i<fgklayernumber; i++){
4908 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4909 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4910 *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4911 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4912 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4913 / kssdlayladdernumber[i])));
4914 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4915 / fgkMountingBlockSupportRadius[i]);
4916 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4917 }
4918 TGeoRotation* globalrot = new TGeoRotation();
4919 globalrot->SetAngles(0.,-90.,0.);
4920 TGeoRotation** laddersupportrot[fgklayernumber];
4921 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4922 for(Int_t i=0; i<fgklayernumber; i++){
4923 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4924 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4925 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4926 laddersupportrot[i][j] = new TGeoRotation();
4927 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4928 switch(i){
4929 case 0: //Ladder of Layer5
4930 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4931 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4932 laddersupportmatrix[i][j]);
4933 break;
4934 case 1: //Ladder of Layer6
4935 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4936 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4937 laddersupportmatrix[i][j]);
4938 break;
4939 }
4940 }
4941 }
4942 /////////////////////////////////////////////////////////////
4943 // Creating Lower Ladder Support
4944 /////////////////////////////////////////////////////////////
4945 TVector3** ringsupportvertex[fgklayernumber];
4946 Double_t angle = 360./nedges;
4947 for(Int_t i=0; i<fgklayernumber; i++){
4948 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4949 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4950 * TMath::Cos(theta[i]));
4951 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4952 - mountingsupportedge[i],
4953 ringsupportvertex[i][0]->Y());
4954 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4955 ringsupportvertex[i][1]->Y());
4956 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4957 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4958 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4959 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4960 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4961 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4962 }
4963 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4964 for(Int_t j=0; j<nedges+1; j++){
4965 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
cd2243fb 4966 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
4967 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle));
9b0c60ab 4968 }
4969 }
4970 Double_t **xmothervertex = new Double_t*[fgklayernumber];
4971 Double_t **ymothervertex = new Double_t*[fgklayernumber];
4972 for(Int_t i=0; i<fgklayernumber; i++){
4973 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4974 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4975 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4976 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4977 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4978 }
4979 }
0e8760e5 4980////////////////////////////////////////////////////////////////////////////////
4981// Start Corrections 13/06/08
4982////////////////////////////////////////////////////////////////////////////////
a3f8715e 4983 char lowerladderpconsupportname[100];
0e8760e5 4984 TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4985 TGeoVolume* lowerladderpconsupport[fgklayernumber];
4986 Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4987 Double_t lowerladderpconradiusmax[fgklayernumber];
4988 Double_t lowerladderpconradiusmin[fgklayernumber];
4989 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4990 lowerladdersupportrot->SetAngles(90.,180.,-90);
4991 for(Int_t i=0; i<fgklayernumber; i++){
4992 lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4993 * TMath::Cos(theta[i]);
cd2243fb 4994 lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
0e8760e5 4995 }
4996 for(Int_t i=0; i<fgklayernumber; i++){
4997/////////////////////////// Modified Version ?///////////////////
4998 lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4999 for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
5000 lowerladderpconezsection[j],lowerladderpconradiusmin[i],
5001 lowerladderpconradiusmax[i]);
5002 sprintf(lowerladderpconsupportname,"LowerLadderPConSupportNameLay%d",i+5);
5003 lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
5004 lowerladderpconsupport[i]->SetLineColor(fColorAl);
5005 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
5006 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
5007 }
5008////////////////////////////////////////////////////////////////////////////////
5009// End Corrections 13/06/08
5010////////////////////////////////////////////////////////////////////////////////
5011 /*char lowerladdersupportname[30];
9b0c60ab 5012 TGeoXtru* lowerladdersupportshape[fgklayernumber];
5013 TGeoVolume* lowerladdersupport[fgklayernumber];
5014 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5015 lowerladdersupportrot->SetAngles(90.,180.,-90);
5016 for(Int_t i=0; i<fgklayernumber; i++){
5017 lowerladdersupportshape[i] = new TGeoXtru(2);
5018 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
5019 xmothervertex[i],ymothervertex[i]);
5020 lowerladdersupportshape[i]->DefineSection(0,0.);
5021 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
5022 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
5023 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
5024 lowerladdersupportshape[i],fSSDSupportRingAl);
5025 lowerladdersupport[i]->SetLineColor(fColorAl);
5026 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
5027 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
0e8760e5 5028 }*/
9b0c60ab 5029 /////////////////////////////////////////////////////////////
5030 // Deallocating memory
5031 /////////////////////////////////////////////////////////////
5032 for(Int_t i=0; i<fgklayernumber; i++){
5033 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
5034 delete ringsupportvertex[i][j];
5035 delete [] ringsupportvertex[i];
5036 }
5037 for(Int_t i=0; i<fgklayernumber; i++){
5038 delete [] xmothervertex[i];
5039 delete [] ymothervertex[i];
5040 }
7b208ef4 5041 delete [] xmothervertex;
5042 delete [] ymothervertex;
9b0c60ab 5043 delete globalrot;
5044 for(Int_t i=0; i<fgklayernumber; i++){
5045 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
5046 delete laddersupportrot[i][j];
5047 delete [] laddersupportrot[i];
5048 }
5049 }
5050 ////////////////////////////////////////////////////////////////////////////////
5051 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
5052 /////////////////////////////////////////////////////////////
5053 // Method generating Endcap CoverPlate
5054 /////////////////////////////////////////////////////////////
5055 // Holes Definition
5056 ///////////////////
5057 Int_t nendcapcoverplateholedges = 30;
5058 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
5059 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
5060 0.5*fgkEndCapCoverPlateThickness};
851c0ce3 5061 TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
9b0c60ab 5062 nendcapcoverplateholedges,holesection);
5063 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 5064 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 5065 endcapcoverplatesmallhole->SetLineColor(6);
851c0ce3 5066 TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
9b0c60ab 5067 nendcapcoverplateholedges,holesection);
5068 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 5069 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 5070 endcapcoverplatebighole->SetLineColor(6);
5071 //////////////////////////
5072 // Screw Piece Definition
5073 //////////////////////////
5074 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
5075 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
5076 CosD(0.5*smallscrewangle),
5077 0.5*fgkEndCapCoverPlateThickness);
5078 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
5079 endcapsmallscrewpieceshape,
5080 fSSDCoolingTubePhynox);
5081 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
5082 ///////////////////
5083 // Box Definition
5084 ///////////////////
5085 TGeoBBox* endcapcoverplateboxshape[4];
5086 TGeoVolume* endcapcoverplatebox[4];
5087 Double_t boxorigin[5][3];
5088 boxorigin[0][0] = 0.;
5089 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
5090 boxorigin[0][2] = 0.;
5091
5092 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
5093 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
5094 boxorigin[1][2] = 0.;
5095
5096 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
5097 + fgkEndCapCoverPlateSmallHoleSeparation[1];
5098 boxorigin[2][1] = boxorigin[1][1];
5099 boxorigin[2][2] = 0.;
5100
5101 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
5102 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
5103 boxorigin[3][1] = boxorigin[1][1];
5104 boxorigin[3][2] = 0.;
5105
5106 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5107 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5108 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
5109 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5110
5111 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5112 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5113 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5114 + fgkEndCapCoverPlateSmallHoleRadius,
5115 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5116
5117 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5118 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5119 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5120 + fgkEndCapCoverPlateSmallHoleRadius,
5121 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5122
5123 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5124 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5125 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5126 + fgkEndCapCoverPlateSmallHoleRadius,
5127 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5128
5129 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 5130 fSSDAlCoolBlockMedium);
9b0c60ab 5131 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 5132 fSSDAlCoolBlockMedium);
9b0c60ab 5133 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 5134 fSSDAlCoolBlockMedium);
9b0c60ab 5135 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 5136 fSSDAlCoolBlockMedium);
9b0c60ab 5137 endcapcoverplatebox[0]->SetLineColor(6);
5138 endcapcoverplatebox[1]->SetLineColor(6);
5139 endcapcoverplatebox[2]->SetLineColor(6);
5140 endcapcoverplatebox[3]->SetLineColor(6);
5141 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5142 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5143 fgkEndCapCoverPlateSmallHoleRadius,
5144 0.5*fgkEndCapCoverPlateThickness,
5145 endcapfillingboxorigin);
5146 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 5147 fSSDAlCoolBlockMedium);
9b0c60ab 5148 endcapfillingbox->SetLineColor(6);
5149 ////////////////////////////
851c0ce3 5150 // Contour shape Definition
9b0c60ab 5151 ////////////////////////////
5152 const Int_t kcontourvertexnumber = 10;
5153 Double_t xcontourvertex[kcontourvertexnumber];
5154 Double_t ycontourvertex[kcontourvertexnumber];
5155 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5156 xcontourvertex[1] = xcontourvertex[0];
5157 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5158 xcontourvertex[3] = xcontourvertex[2];
5159 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5160 xcontourvertex[5] = xcontourvertex[4];
5161 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5162 xcontourvertex[7] = xcontourvertex[6];
5163 xcontourvertex[8] = xcontourvertex[4];
5164 xcontourvertex[9] = xcontourvertex[8];
5165 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5166 - (kendcapcoverplatesmallholenumber[1]-1)
5167 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5168 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5169 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5170 ycontourvertex[2] = ycontourvertex[1];
5171 ycontourvertex[3] = ycontourvertex[0];
5172 ycontourvertex[4] = ycontourvertex[3];
5173 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5174 ycontourvertex[6] = ycontourvertex[5];
5175 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5176 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5177 + fgkEndCapCoverPlateSmallHoleRadius;
5178 ycontourvertex[8] = ycontourvertex[7];
5179 ycontourvertex[9] = ycontourvertex[0];
851c0ce3 5180
5181 Double_t xboxin, dxboxin, yboxin, dyboxin;
5182 Double_t xboxout, dxboxout, yboxout, dyboxout;
5183 Double_t coordmin, coordmax;
5184 coordmin = -fgkEndCapCoverPlateLength[0];
5185 coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5186 xboxout = 0.5*(coordmin+coordmax);
5187 dxboxout = 0.5*(coordmax-coordmin);
5188 coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5189 - (kendcapcoverplatesmallholenumber[1]-1)
5190 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5191 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5192 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5193 yboxout = 0.5*(coordmin+coordmax);
5194 dyboxout = 0.5*(coordmax-coordmin);
5195 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5196 coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5197 xboxin = 0.5*(coordmin+coordmax);
5198 dxboxin = 0.5*(coordmax-coordmin);
5199 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5200 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5201 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5202 + fgkEndCapCoverPlateSmallHoleRadius;
5203 yboxin = 0.5*(coordmin+coordmax);
5204 dyboxin = 0.5*(coordmax-coordmin);
5205 new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5206 TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5207 xboxout, yboxout, 0.);
5208 trendCapCoverPlateContourboxout->RegisterYourself();
5209 new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5210 TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5211 xboxin, yboxin, 0.);
5212 trendCapCoverPlateContourboxin->RegisterYourself();
5213 TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5214 "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5215
e21cdd03 5216 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5217 fSSDAlCoolBlockMedium);
9b0c60ab 5218 contour->SetLineColor(6);
5219 /////////////////////////////
851c0ce3 5220 // Hole Contour Shape Definition
9b0c60ab 5221 ////////////////////////////
851c0ce3 5222 coordmin = xcontourvertex[0];
5223 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5224 xboxout = 0.5*(coordmin+coordmax);
5225 dxboxout = 0.5*(coordmax-coordmin);
5226 coordmin = ycontourvertex[1];
5227 coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5228 yboxout = 0.5*(coordmin+coordmax);
5229 dyboxout = 0.5*(coordmax-coordmin);
5230 coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5231 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5232 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5233 xboxin = 0.5*(coordmin+coordmax);
5234 dxboxin = 0.5*(coordmax-coordmin);
5235 coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5236 - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5237 coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5238 yboxin = 0.5*(coordmin+coordmax);
5239 dyboxin = 0.5*(coordmax-coordmin);
5240 new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5241 TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5242 xboxout, yboxout, 0.);
5243 trendCapCoverPlateContourboxout1->RegisterYourself();
5244 new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5245 TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5246 xboxin, yboxin, 0.);
5247 trendCapCoverPlateContourboxin1->RegisterYourself();
5248 TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5249 "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5250
5251
5252 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5253 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5254 xboxout = 0.5*(coordmin+coordmax);
5255 dxboxout = 0.5*(coordmax-coordmin);
5256 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5257 - fgkEndCapCoverPlateWidth[0]);
5258 coordmax = ycontourvertex[0];
5259 yboxout = 0.5*(coordmin+coordmax);
5260 dyboxout = 0.5*(coordmax-coordmin);
5261 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5262 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5263 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5264 xboxin = 0.5*(coordmin+coordmax);
5265 dxboxin = 0.5*(coordmax-coordmin);
5266 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5267 - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5268 - fgkEndCapCoverPlateWidth[0]
5269 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5270 coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5271 yboxin = 0.5*(coordmin+coordmax);
5272 dyboxin = 0.5*(coordmax-coordmin);
5273 new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5274 TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5275 xboxout, yboxout, 0.);
5276 trendCapCoverPlateContourboxout2->RegisterYourself();
5277 new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5278 TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5279 xboxin, yboxin, 0.);
5280 trendCapCoverPlateContourboxin2->RegisterYourself();
5281 TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5282 "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5283
5284// const Int_t kholecontourvertexnumber = 10;
5285
9b0c60ab 5286 Double_t xholecontourvertex[2][kcontourvertexnumber];
5287 Double_t yholecontourvertex[2][kcontourvertexnumber];
5288 xholecontourvertex[0][0] = xcontourvertex[0];
5289 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5290 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5291 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5292 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5293 + 0.5*(fgkEndCapCoverPlateLength[2]
5294 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5295 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5296 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5297 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5298 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5299 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5300 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5301
5302 yholecontourvertex[0][0] = ycontourvertex[1];
5303 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5304 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5305 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5306 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5307 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5308 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5309 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5310 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5311 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5312 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5313
5314 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5315 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5316 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5317 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5318 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5319 + 0.5*(fgkEndCapCoverPlateLength[2]
5320 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5321 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5322 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5323 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5324 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5325 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5326 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5327
5328 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5329 - fgkEndCapCoverPlateWidth[0]);
5330 yholecontourvertex[1][1] = ycontourvertex[0];
5331 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5332 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5333 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5334 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5335 - fgkEndCapCoverPlateWidth[0]
5336 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5337 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5338 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5339 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5340 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5341
9b0c60ab 5342 TGeoVolume* holecontour[2];
851c0ce3 5343 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
e21cdd03 5344 fSSDAlCoolBlockMedium);
9b0c60ab 5345 holecontour[0]->SetLineColor(6);
851c0ce3 5346 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
e21cdd03 5347 fSSDAlCoolBlockMedium);
9b0c60ab 5348 holecontour[1]->SetLineColor(6);
5349 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5350 + fgkEndCapCoverPlateLength[2],0.,0.);
5351 TGeoTranslation* bigholetrans[3];
5352 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5353 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5354 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5355 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5356 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5357 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5358 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5359 /////////////////////////////////
5360 // Mother Volume Xtru Definition
5361 /////////////////////////////////
5362 const Int_t kmothervertexnumber = 12;
5363 Double_t xmothervertex[kmothervertexnumber];
5364 Double_t ymothervertex[kmothervertexnumber];
5365 xmothervertex[0] = xcontourvertex[0];
5366 xmothervertex[1] = xmothervertex[0];
5367 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5368 xmothervertex[3] = xmothervertex[2];
5369 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5370 xmothervertex[5] = xmothervertex[4];
5371 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5372 xmothervertex[7] = xmothervertex[6];
5373 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5374 + fgkEndCapCoverPlateLength[2];
5375 xmothervertex[9] = xmothervertex[8];
5376 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5377 xmothervertex[11] = xmothervertex[10];
5378
5379 ymothervertex[0] = ycontourvertex[0];
5380 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5381 ymothervertex[2] = ymothervertex[1];
5382 ymothervertex[3] = ycontourvertex[1];
5383 ymothervertex[4] = ymothervertex[3];
5384 ymothervertex[5] = ymothervertex[1];
5385 ymothervertex[6] = ymothervertex[5];
5386 ymothervertex[7] = ymothervertex[0];
5387 ymothervertex[8] = ymothervertex[7];
5388 ymothervertex[9] = ymothervertex[8]
5389 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5390 ymothervertex[10] = ymothervertex[9];
5391 ymothervertex[11] = ymothervertex[8];
5392 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5393 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5394 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5395 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5396 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5397 ////////////////////////////////////////
5398 // Adding Nodes
5399 ////////////////////////////////////////
5400// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5401 TGeoTranslation*** endcapcoverplatesmallholetrans;
5402 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5403 Double_t transx[4] = {0,
5404 fgkEndCapCoverPlateSmallHoleSeparation[0],
5405 fgkEndCapCoverPlateSmallHoleSeparation[0]
5406 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5407 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5408 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5409 Int_t index = 0;
5410 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5411 endcapcoverplatesmallholetrans[i] =
5412 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5413 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5414 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5415 endcapcoverplatesmallholetrans[i][j] =
5416 new TGeoTranslation(transx[i],
5417 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5418 if(index!=10){
5419 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5420 index,endcapcoverplatesmallholetrans[i][j]);
5421 mothercoverplate->AddNode(endcapsmallscrewpiece,
5422 index,endcapcoverplatesmallholetrans[i][j]);
5423 }
5424 if(j<kendcapcoverplatesmallholenumber[1]-1)
5425 mothercoverplate->AddNode(endcapcoverplatebox[0],
5426 index,endcapcoverplatesmallholetrans[i][j]);
5427 }
5428 }
5429 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5430 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5431 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5432 mothercoverplate->AddNode(endcapfillingbox,1);
5433 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5434 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5435 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5436 mothercoverplate->AddNode(holecontour[0],1);
5437 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5438 mothercoverplate->AddNode(holecontour[1],1);
5439 mothercoverplate->AddNode(contour,1);
5440 /////////////////////////////////
5441 return mothercoverplate;
5442 }
5443 ////////////////////////////////////////////////////////////////////////////////
5444 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5445 /////////////////////////////////////////////////////////////
5446 // Getting EndCap Cooling Tube
5447 /////////////////////////////////////////////////////////////
5448 TGeoTorus* endcapcoolingtubetorushape[5];
5449 TGeoVolume* endcapcoolingtubetorus[5];
5450 TGeoTube* endcapcoolingtubeshape[4];
5451 TGeoVolume* endcapcoolingtube[4];
a3f8715e 5452 char endcapcoolingtubetorusname[100];
5453 char endcapcoolingtubename[100];
9b0c60ab 5454 TGeoTorus* endcapcoolingwatertubetorushape[5];
5455 TGeoVolume* endcapcoolingwatertubetorus[5];
5456 TGeoTube* endcapcoolingwatertubeshape[4];
5457 TGeoVolume* endcapcoolingwatertube[4];
a3f8715e 5458 char endcapcoolingwatertubetorusname[100];
5459 char endcapcoolingwatertubename[100];
9b0c60ab 5460 for(Int_t i=0; i<5; i++){
5461 sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5462 sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5463 sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5464 sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5465 if(i==3){
5466 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5467 fgkEndCapCoolingTubeRadiusMin,
5468 fgkEndCapCoolingTubeRadiusMax,
5469 90.0,fgkEndCapCoolingTubeAngle[3]);
5470 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5471 0.,fgkEndCapCoolingTubeRadiusMin,
5472 90.0,fgkEndCapCoolingTubeAngle[3]);
5473 }
5474 else{
5475 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5476 :fgkEndCapCoolingTubeAxialRadius[1],
5477 fgkEndCapCoolingTubeRadiusMin,
5478 fgkEndCapCoolingTubeRadiusMax,
5479 0.,fgkEndCapCoolingTubeAngle[i]);
5480 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5481 :fgkEndCapCoolingTubeAxialRadius[1],
5482 0.,fgkEndCapCoolingTubeRadiusMin,
5483 0.,fgkEndCapCoolingTubeAngle[i]);
5484 }
5485 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5486 endcapcoolingtubetorushape[i],
5487 fSSDCoolingTubePhynox);
5488 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5489 endcapcoolingwatertubetorushape[i],
5490 fSSDCoolingTubeWater);
5491 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5492 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5493 if(i<4){
5494 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5495 fgkEndCapCoolingTubeRadiusMax,
5496 0.5*fgkEndCapCoolingTubeLength[i]);
5497 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5498 0.5*fgkEndCapCoolingTubeLength[i]);
5499 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5500 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5501 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5502 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5503 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5504 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5505 }
5506 }
5507 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5508 /////////////////////////////////////////
5509 // Transformation for Volume Positioning
5510 /////////////////////////////////////////
5511 TGeoCombiTrans* coolingtubecombitrans[6];
5512 TGeoRotation* coolingtuberot[8];
5513 TGeoTranslation* coolingtubetrans[6];
5514 TGeoHMatrix* coolingtubematrix[4];
5515 TGeoCombiTrans* torustubecombitrans[4];
5516 TGeoRotation* torustuberot[7];
5517 TGeoTranslation* torustubetrans[4];
5518 TGeoHMatrix* torustubematrix[5];
5519 TGeoCombiTrans* coolingwatertubecombitrans[6];
5520 TGeoRotation* coolingwatertuberot[8];
5521 TGeoTranslation* coolingwatertubetrans[6];
5522 TGeoHMatrix* coolingwatertubematrix[4];
5523 TGeoCombiTrans* toruswatertubecombitrans[4];
5524 TGeoRotation* toruswatertuberot[7];
5525 TGeoTranslation* toruswatertubetrans[4];
5526 TGeoHMatrix* toruswatertubematrix[5];
5527 for(Int_t i=0; i<8; i++){
5528 if(i<6){
5529 coolingtubetrans[i] = new TGeoTranslation();
5530 coolingwatertubetrans[i] = new TGeoTranslation();
5531 }
5532 if(i<8){
5533 coolingtuberot[i] = new TGeoRotation();
5534 coolingwatertuberot[i] = new TGeoRotation();
5535 }
5536 if(i<4){
5537 torustubetrans[i] = new TGeoTranslation();
5538 toruswatertubetrans[i] = new TGeoTranslation();
5539 }
5540 if(i<7){
5541 torustuberot[i] = new TGeoRotation();
5542 toruswatertuberot[i] = new TGeoRotation();
5543 }
5544 }
5545 /////////////////////////////////////////
5546 // Transformation for Inox Volume Positioning
5547 /////////////////////////////////////////
5548 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5549 -endcapcoolingtubeshape[0]->GetDz(),0.);
5550 coolingtuberot[0]->SetAngles(0.,90.,0.);
5551 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5552 *coolingtuberot[0]);
5553
5554 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5555 coolingtuberot[1]->SetAngles(0.,90.,0.);
5556 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5557 *coolingtuberot[1]);
5558
5559 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5560 *CosD(fgkEndCapCoolingTubeAngle[0]),
5561 fgkEndCapCoolingTubeAxialRadius[0]
5562 *SinD(fgkEndCapCoolingTubeAngle[0]),
5563 0.);
5564 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5565 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5566 *coolingtuberot[2]);
5567
5568 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5569 * (*coolingtubecombitrans[1]));
5570
5571 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5572 endcapcoolingtubeshape[1]->GetDz());
5573 torustuberot[0]->SetAngles(0.,90.,0.);
5574 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5575
5576 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5577
5578 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5579 -endcapcoolingtubeshape[2]->GetDz(),0.);
5580 coolingtuberot[3]->SetAngles(0.,90.,0.);
5581 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5582 *coolingtuberot[3]);
5583 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5584 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5585 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5586
5587 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5588 endcapcoolingtubeshape[2]->GetDz());
5589 torustuberot[1]->SetAngles(0.,90.,0.);
5590 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5591 torustuberot[2]->SetAngles(180.,0.,0.);
5592 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5593 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5594
5595 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5596 -fgkEndCapCoolingTubeAxialRadius[0]);
5597 torustuberot[3]->SetAngles(0.,90.,0.);
5598 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5599 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5600 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5601 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5602
5603 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5604 fgkEndCapCoolingTubeAxialRadius[0],0.);
5605 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5606 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5607 *coolingtuberot[5]);
5608 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5609 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5610 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5611
5612 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5613 endcapcoolingtubeshape[0]->GetDz());
5614 torustuberot[5]->SetAngles(0.,90.,0.);
5615 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5616 torustuberot[6]->SetAngles(-90.,0.,0.);
5617 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5618 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5619
5620 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5621 endcapcoolingtubeshape[3]->GetDz(),0.);
5622 coolingtuberot[6]->SetAngles(0.,90.,0.);
5623 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5624 *coolingtuberot[6]);
5625 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5626 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5627 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5628 /////////////////////////////////////////
5629 // Transformation for Water Volume Positioning
5630 /////////////////////////////////////////
5631 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5632 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5633 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5634 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5635 *coolingwatertuberot[0]);
5636
5637 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5638 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5639 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5640 *coolingwatertuberot[1]);
5641
5642 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5643 *CosD(fgkEndCapCoolingTubeAngle[0]),
5644 fgkEndCapCoolingTubeAxialRadius[0]
5645 *SinD(fgkEndCapCoolingTubeAngle[0]),
5646 0.);
5647 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5648 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5649 *coolingwatertuberot[2]);
5650
5651 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5652 * (*coolingwatertubecombitrans[1]));
5653
5654 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5655 endcapcoolingwatertubeshape[1]->GetDz());
5656 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5657 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5658 *toruswatertuberot[0]);
5659
5660 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5661 * (*toruswatertubecombitrans[0]));
5662
5663 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5664 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5665 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5666 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5667 *coolingwatertuberot[3]);
5668 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5669 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5670 * (*coolingwatertubecombitrans[3]));
5671 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5672
5673 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5674 endcapcoolingwatertubeshape[2]->GetDz());
5675 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5676 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5677 *toruswatertuberot[1]);
5678 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5679 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5680 * (*toruswatertubecombitrans[1]));
5681 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5682
5683 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5684 -fgkEndCapCoolingTubeAxialRadius[0]);
5685 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5686 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5687 *toruswatertuberot[3]);
5688 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5689 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5690 * (*toruswatertubecombitrans[2]));
5691 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5692
5693 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5694 fgkEndCapCoolingTubeAxialRadius[0],0.);
5695 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5696 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5697 *coolingwatertuberot[5]);
5698 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5699 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5700 * (*coolingwatertubecombitrans[4]));
5701 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5702
5703 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5704 endcapcoolingwatertubeshape[0]->GetDz());
5705 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5706 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5707 *toruswatertuberot[5]);
5708 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5709 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5710 * (*toruswatertubecombitrans[3]));
5711 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5712
5713 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5714 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5715 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5716 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5717 *coolingwatertuberot[6]);
5718 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5719 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5720 * (*coolingwatertubecombitrans[5]));
5721 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5722 /////////////////////////////////////////
5723 // Positioning Volumes
5724 /////////////////////////////////////////
5725 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5726 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5727
5728 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5729 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5730
5731 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5732 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5733
5734 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5735 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5736
5737 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5738 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5739
5740 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5741 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5742
5743 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5744 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5745
5746 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5747 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5748
5749 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5750 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5751
5752 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5753 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5754 /////////////////////////////////////////////////////////////
5755 // Deallocating memory
5756 /////////////////////////////////////////////////////////////
5757 for(Int_t i=0; i<8; i++){
5758 if(i<6){
5759 delete coolingtubetrans[i];
5760 delete coolingwatertubetrans[i];
5761 if(i!=0){
5762 delete coolingtubecombitrans[i];
5763 delete coolingwatertubecombitrans[i];
5764 }
5765 }
5766 if(i<8){
5767 delete coolingtuberot[i];
5768 delete coolingwatertuberot[i];
5769 }
5770 if(i<4){
5771 delete torustubetrans[i];
5772 delete toruswatertubetrans[i];
5773 delete torustubecombitrans[i];
5774 delete toruswatertubecombitrans[i];
5775 }
5776 if(i<7){
5777 delete torustuberot[i];
5778 delete toruswatertuberot[i];
5779 }
5780 }
5781 /////////////////////////////////////////////////////////////
5782 return endcapcoolingtubemother;
5783 }
5784 ////////////////////////////////////////////////////////////////////////////////
5785 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5786 /////////////////////////////////////////////////////////////
5787 // Getting EndCap Cover Side
5788 /////////////////////////////////////////////////////////////
5789 const Int_t kendcapcoverholenumber[2] = {7,5};
5790 const Int_t kvertexnumber = 15;
5791 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5792 xvertex[0] = 0.0;
5793 xvertex[1] = xvertex[0];
5794 xvertex[2] = fgkEndCapSideCoverLength[0];
5795 xvertex[3] = fgkEndCapSideCoverLength[1];
5796 xvertex[4] = xvertex[3];
5797 xvertex[5] = fgkEndCapSideCoverLength[2];
5798 xvertex[6] = xvertex[5];
5799 xvertex[7] = xvertex[2];
5800 xvertex[8] = xvertex[7];
5801 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5802 xvertex[10] = xvertex[9];
5803 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5804 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5805 * fgkEndCapSideCoverLength[4];
5806 xvertex[12] = xvertex[11];
5807 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5808 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5809 * fgkEndCapSideCoverLength[4];
5810 xvertex[14] = xvertex[13];
5811 yvertex[0] = 0.0;
5812 yvertex[1] = fgkEndCapSideCoverWidth[0];
5813 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5814 yvertex[3] = yvertex[2];
5815 yvertex[4] = fgkEndCapSideCoverWidth[1];
5816 yvertex[5] = yvertex[4];
5817 yvertex[6] = yvertex[0];
5818 yvertex[7] = yvertex[6];
5819 yvertex[8] = fgkEndCapSideCoverWidth[6];
5820 yvertex[9] = yvertex[8];
5821 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5822 yvertex[11] = yvertex[10];
5823 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5824 yvertex[13] = yvertex[12];
5825 yvertex[14] = yvertex[6];
851c0ce3 5826 TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5827 endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5828 endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5829 endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5830 endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5831 TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5832 endcapsidecovershapein->SetName("endcapsidecovershapein");
5833 endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5834 endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5835 endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5836
5837
5838 TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
9b0c60ab 5839 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5840 endcapsidecovershape,fSSDCoolingTubePhynox);
5841 endcapsidecover->SetLineColor(fColorPhynox);
5842 ////////////////////////////////////////////
5843 // Defininition of Mother Volume
5844 ////////////////////////////////////////////
5845 const Int_t kmothervertexnumber = 7;
5846 Double_t xmothervertex[kmothervertexnumber];
5847 Double_t ymothervertex[kmothervertexnumber];
5848 for(Int_t i=0; i<kmothervertexnumber; i++){
5849 xmothervertex[i] = xvertex[i];
5850 ymothervertex[i] = yvertex[i];
5851 }
5852 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5853 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5854 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5855 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5856 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5857 endcapsidecovermothershape,fSSDAir);
5858 ////////////////////////////////////////////
5859 endcapsidecovermother->AddNode(endcapsidecover,1);
5860 TGeoBBox* endcapsidecoverboxshape[4];
5861 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5862 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5863 0.5*fgkEndCapSideCoverLength[4],
5864 0.5*fgkEndCapSideCoverThickness);
5865 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5866 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5867 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5868 - fgkEndCapSideCoverLength[4]),
5869 0.5*fgkEndCapSideCoverThickness);
5870 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5871 0.5*fgkEndCapSideCoverLength[4],
5872 0.5*fgkEndCapSideCoverThickness);
5873 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5874 0.5*fgkEndCapSideCoverWidth[5],
5875 0.5*fgkEndCapSideCoverThickness);
5876 TGeoVolume* endcapsidecoverbox[4];
5877 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5878 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5879 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5880 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5881 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5882// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5883 TGeoTranslation** endcapsidecoverboxtrans;
5884 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5885 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5886 + fgkEndCapSideCoverLength[0],
5887 endcapsidecoverboxshape[0]->GetDY()
5888 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5889 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5890 + xvertex[11],
5891 endcapsidecoverboxshape[1]->GetDY()
5892 + yvertex[12],0.);
5893 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5894 + xvertex[11],
5895 endcapsidecoverboxshape[2]->GetDY()
5896 + yvertex[12]
5897 + 2.*endcapsidecoverboxshape[1]->GetDY()
5898 + fgkEndCapSideCoverWidth[5],0.);
5899 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5900 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5901 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5902 for(Int_t i=0; i<2; i++)
5903 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5904 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5905 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5906 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5907 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5908 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5909 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5910 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5911 }
5912 for(Int_t i=0; i<2; i++)
5913 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5914 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5915 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5916 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5917 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5918 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5919 +fgkEndCapSideCoverLength[4]),0.0);
5920 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5921 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5922 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5923 +i*(kendcapcoverholenumber[1]-1)+j]);
5924 }
5925 return endcapsidecovermother;
5926 }
5927 ////////////////////////////////////////////////////////////////////////////////
5928 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5929 ////////////////////////////////////////////////////////////////////////////////
5930 // Method returning Interface Card A, Interface Card B, Supply Card
5931 ////////////////////////////////////////////////////////////////////////////////
5932 /////////////////////
5933 // Supply Card
5934 /////////////////////
5935 // Electronic Board Back Al Plane
5936 const Int_t kelectboardbackvertexnumber = 8;
5937 Double_t xelectboardback[kelectboardbackvertexnumber];
5938 Double_t yelectboardback[kelectboardbackvertexnumber];
5939 xelectboardback[0] = 0.0;
5940 xelectboardback[1] = xelectboardback[0];
5941 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5942 xelectboardback[3] = xelectboardback[2];
5943 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5944 xelectboardback[5] = xelectboardback[4];
5945 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5946 xelectboardback[7] = xelectboardback[6];
5947
5948 yelectboardback[0] = 0.0;
5949 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5950 yelectboardback[2] = yelectboardback[1];
5951 yelectboardback[3] = yelectboardback[0];
5952 yelectboardback[4] = yelectboardback[3];
5953 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5954 yelectboardback[6] = yelectboardback[5];
5955 yelectboardback[7] = yelectboardback[4];
5956 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5957 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5958 xelectboardback,yelectboardback);
5959 electboardbackshape->DefineSection(0,0.0);
5960 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5961 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5962 electboardbackshape,fSSDSupportRingAl);
5963 electboardback->SetLineColor(fColorAl);
5964 // Electronic Board Kapton Layer
5965 const Int_t kelectlayervertexnumber = 8;
5966 Double_t xelectlayer[kelectlayervertexnumber];
5967 Double_t yelectlayer[kelectlayervertexnumber];
5968 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5969 xelectlayer[1] = xelectlayer[0];
5970 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5971 xelectlayer[3] = xelectlayer[2];
5972 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5973
5974 yelectlayer[0] = 0.0;
5975 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5976 yelectlayer[2] = yelectlayer[1];
5977 yelectlayer[3] = yelectlayer[0];
5978 yelectlayer[4] = yelectlayer[3];
5979 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5980 yelectlayer[6] = yelectlayer[5];
5981 yelectlayer[7] = yelectlayer[4];
5982 TGeoXtru* electlayershape = new TGeoXtru(2);
5983 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5984 electlayershape->DefineSection(0,0.0);
5985 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5986 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5987 electlayershape,fSSDKaptonFlexMedium);
5988 electlayer->SetLineColor(fColorKapton);
5989 // JMD Connector Female
5990 const Int_t kjmdconnectorvertexnumber = 6;
5991 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5992 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5993 xjmdconnectorvertex[0] = 0.0;
5994 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5995 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5996 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5997 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5998 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5999
6000 yjmdconnectorvertex[0] = 0.0;
6001 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
6002 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
6003 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
6004 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
6005 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
6006 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
6007 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
6008 yjmdconnectorvertex);
6009 jmdconnectorshape->DefineSection(0,0.0);
6010 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
6011 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
6012 jmdconnectorshape,fSSDMountingBlockMedium);
6013 jmdconnector->SetLineColor(fColorG10);
6014 // Top Cable Connector
6015 const Int_t kcableconnectorvertexnumber = 8;
6016 Double_t xconnectorvertex[kcableconnectorvertexnumber];
6017 Double_t yconnectorvertex[kcableconnectorvertexnumber];
6018 xconnectorvertex[0] = 0.0;
6019 xconnectorvertex[1] = xconnectorvertex[0];
6020 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
6021 xconnectorvertex[3] = xconnectorvertex[2];
6022 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
6023 - fgkEndCapCardCableConnectorLength[2];
6024 xconnectorvertex[5] = xconnectorvertex[4];
6025 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
6026 xconnectorvertex[7] = xconnectorvertex[6];
6027
6028 yconnectorvertex[0] = 0.0;
6029 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
6030 yconnectorvertex[2] = yconnectorvertex[1];
6031 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
6032 yconnectorvertex[4] = yconnectorvertex[3];
6033 yconnectorvertex[5] = yconnectorvertex[1];
6034 yconnectorvertex[6] = yconnectorvertex[5];
6035 yconnectorvertex[7] = yconnectorvertex[0];
6036 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
6037 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
6038 yconnectorvertex);
6039 cableconnectorshape->DefineSection(0,0.0);
6040 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
6041 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
6042 cableconnectorshape,fSSDMountingBlockMedium);
6043 cableconnector->SetLineColor(fColorG10);
6044 // Strip Connection
6045 TGeoBBox* endcapstripconnectionshape =
6046 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
6047 0.5*fgkEndCapStripConnectionThickness,
6048 0.5*fgkEndCapStripConnectionWidth);
6049 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
6050 endcapstripconnectionshape,
6051 fSSDSupportRingAl);
6052 endcapstripconnection->SetLineColor(fColorAl);
6053 // Interface Card B
6054 const Int_t kcardBvertexnumber = 12;
6055 Double_t xcardBvertexnumber[kcardBvertexnumber];
6056 Double_t ycardBvertexnumber[kcardBvertexnumber];
6057
6058 xcardBvertexnumber[0] = 0.0;
6059 xcardBvertexnumber[1] = xcardBvertexnumber[0];
6060 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
6061 xcardBvertexnumber[3] = xcardBvertexnumber[2];
6062 xcardBvertexnumber[4] = xcardBvertexnumber[1];
6063 xcardBvertexnumber[5] = xcardBvertexnumber[4];
6064 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
6065 xcardBvertexnumber[7] = xcardBvertexnumber[6];
6066 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
6067 xcardBvertexnumber[9] = xcardBvertexnumber[8];
6068 xcardBvertexnumber[10] = xcardBvertexnumber[7];
6069 xcardBvertexnumber[11] = xcardBvertexnumber[10];
6070
6071 ycardBvertexnumber[0] = 0.0;
6072 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
6073 ycardBvertexnumber[2] = ycardBvertexnumber[1];
6074 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
6075 ycardBvertexnumber[4] = ycardBvertexnumber[3];
6076 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
6077 ycardBvertexnumber[6] = ycardBvertexnumber[5];
6078 ycardBvertexnumber[7] = ycardBvertexnumber[4];
6079 ycardBvertexnumber[8] = ycardBvertexnumber[7];
6080 ycardBvertexnumber[9] = ycardBvertexnumber[1];
6081 ycardBvertexnumber[10] = ycardBvertexnumber[9];
6082 ycardBvertexnumber[11] = ycardBvertexnumber[0];
6083
6084 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
6085 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
6086 interfacecardBshape->DefineSection(0,0.);
6087 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
6088 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
6089 fSSDMountingBlockMedium);
6090 interfacecardB->SetLineColor(46);
6091 // Interface Card B Electronic Board
6092 const Int_t kelectboardcardBvertexnumber = 14;
6093 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
6094 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
6095
6096 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
6097 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
6098 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
6099 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
6100 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
6101 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
6102 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6103 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
6104 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6105 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
6106 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6107 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6108 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6109 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6110
6111 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6112 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6113 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
6114 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6115 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
6116 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
6117 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
6118 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6119 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
6120 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6121 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6122 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6123 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6124 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6125
6126 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6127 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6128 xelectboardcardBvertex,yelectboardcardBvertex);
6129 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6130 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6131 + fgkEndCapInterfaceElectBoardCardBThickness);
6132 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6133 fSSDSupportRingAl);
6134 electboardcardB->SetLineColor(fColorAl);
6135 // Generating Stiffener 2
6136 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6137 0.5*fgkEndCapStiffenerThickness,
6138 0.5*fgkEndCapStiffenerLength);
6139 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6140 endcapstiffener->SetLineColor(fColorAl);
6141 // Generating Mother Interface Card B Container
6142 const Int_t kinterfacecardBmothervertexnumber = 10;
6143 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6144 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6145
6146 xinterfacecardBmothervertex[0] = 0.0;
6147 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6148 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6149 + fgkEndCapInterfaceCardBThickness;
6150 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6151 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6152 + fgkEndCapInterfaceElectBoardCardBThickness;
6153 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6154 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6155 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6156 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6157 + fgkEndCapCardJMDConnectorLength[0];
6158 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6159
6160 yinterfacecardBmothervertex[0] = 0.0;
6161 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6162 + fgkEndCapInterfaceCardBWidth[1]
6163 + fgkEndCapInterfaceCardBWidth[2];
6164 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6165 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6166 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6167 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6168 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6169 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6170 + fgkEndCapCardJMDConnectorWidth[0]
6171 + fgkEndCapCardJMDConnectorWidth[1];
6172 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6173 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6174 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6175 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6176 xinterfacecardBmothervertex,
6177 yinterfacecardBmothervertex);
6178 interfacecardBmothershape->DefineSection(0,-1.e-15);
6179 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6180 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6181 interfacecardBmothershape,fSSDAir);
6182 electboardcardB->SetLineColor(fColorAl);
6183 // Positioning Volumes Mother Interface Card B Container
6184 TGeoRotation* interfacecardBrot = new TGeoRotation();
6185 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6186 interfacecardBrot->SetAngles(90.,-90.,-90.);
6187 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6188 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6189 TGeoRotation* electboardcardBrot = new TGeoRotation();
6190 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6191 electboardcardBrot->SetAngles(90.,90.,-90.);
6192 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6193 TGeoCombiTrans* electboardcardBcombitrans =
6194 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6195 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6196 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6197 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6198 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6199 TGeoTranslation* jmdconnectorcardBtrans[3];
6200 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6201 for(Int_t i=0; i<3; i++){
6202 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6203 + fgkEndCapCardJMDConnectorLength[0],
6204 fgkEndCapCardElectBoardLayerWidth[1],
6205 0.5*fgkEndCapCardJMDConnectorThickness
6206 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6207 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6208 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6209 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6210 *jmdconnectorcardBrot);
6211 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6212 }
6213 // Mother Supply Card Container
6214 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6215 // Interface Card Container
6216 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6217 // Placing Volumes in Mother Supply Card Container
6218 // JMD Connector Positioning
6219 TGeoTranslation* jmdconnectortrans[2];
6220 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6221 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6222 fgkEndCapCardElectBoardBackLength[0]
6223 - fgkEndCapCardJMDConnectorThickness
6224 - fgkEndCapCardJMDConnectorToLayer);
6225 TGeoRotation* jmdconnectorot = new TGeoRotation();
6226 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6227 + 2.*fgkEndCapCardJMDConnectorLength[0]
6228 + 2.*fgkEndCapCardElectBoardLayerThickness,
6229 fgkEndCapCardElectBoardLayerWidth[1],
6230 fgkEndCapCardJMDConnectorThickness
6231 + fgkEndCapCardJMDConnectorToLayer);
6232 jmdconnectorot->SetAngles(90.,180.,-90);
6233 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6234 * jmdconnectorot);
6235 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6236 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6237 // Top Cable Connector Placing
6238 TGeoRotation* cableconnectorot[2];
6239 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6240 TGeoTranslation* cableconnectortrans[3];
6241 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6242 cableconnectorot[0]->SetAngles(90.,0.,0.);
6243 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6244 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6245 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6246 *cableconnectorot[0]);
6247 TGeoHMatrix* cableconnectormatrix[2];
6248 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6249 new TGeoHMatrix((*cableconnectorot[1])
6250 *(*cableconnectorcombitrans));
6251 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6252 - fgkEndCapCardCableConnectorThickness,
6253 fgkEndCapCardCableConnectorLength[0]
6254 + fgkEndCapCardCableConnectorToLayer);
6255 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6256 - 2.*fgkEndCapCardCableConnectorThickness
6257 - fgkEndCapCardCableConnectorDistance,
6258 fgkEndCapCardCableConnectorLength[0]
6259 + fgkEndCapCardCableConnectorToLayer);
6260 for(Int_t i=0; i<2; i++){
6261 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6262 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6263 }
6264 TGeoRotation* electboardbackrot = new TGeoRotation();
6265 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6266 electboardbackrot->SetAngles(90.,-90.,-90.);
6267 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6268 + fgkEndCapCardJMDConnectorLength[0]
6269 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6270 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6271 *electboardbackrot);
6272 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6273 // Electronic Board Kapton Layer Positioning
6274 TGeoRotation* electlayerrot = new TGeoRotation();
6275 TGeoTranslation* electlayertrans[2];
6276 TGeoCombiTrans* electlayercombitrans[2];
6277 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6278 electlayerrot->SetAngles(90.,-90.,-90.);
6279 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6280 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6281 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6282 + 2.*fgkEndCapCardElectBoardLayerThickness
6283 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6284 for(Int_t i=0; i<2; i++){
6285 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6286 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6287 }
6288 // Placing Volumes in Mother Interface Card Container
6289 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6290 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6291 for(Int_t i=0; i<2; i++){
6292 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6293 }
6294 /////////////////////////////////////////////////////////////
6295 // Generation of Card Interface Container
6296 /////////////////////////////////////////////////////////////
6297 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6298 - fgkEndCapCardJMDConnectorLength[0]
6299 - fgkEndCapInterfaceCardBThickness
6300 - 9.*fgkEndCapStripConnectionThickness
6301 - 8.*fgkEndCapCardElectBoardBackThickness;
6302 const Int_t kcardinterfacecontainervertexnumber = 14;
6303 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6304 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6305 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6306 - 7.0*fgkEndCapStripConnectionThickness;
6307 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6308 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6309 + fgkEndCapStripConnectionThickness
6310 - fgkEndCapCardElectBoardLayerThickness
6311 - fgkEndCapCardCableConnectorWidth[0];
6312 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6313 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6314 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6315 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6316 + 2.0*fgkEndCapStripConnectionThickness;
6317 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6318 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6319 + fgkEndCapInterfaceCardBThickness;
6320 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6321 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6322 + fgkEndCapInterfaceElectBoardCardBThickness;
6323 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6324 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6325 - fgkEndCapInterfaceElectBoardCardBThickness
6326 + fgkEndCapCardJMDConnectorLength[0]
6327 + stiffenertransx+fgkEndCapStiffenerWidth;
6328 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6329
6330 ycardinterfacecontainervertex[0] = 0.;
6331 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6332 + fgkEndCapCardJMDConnectorWidth[0]
6333 + fgkEndCapCardJMDConnectorWidth[1];
6334 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6335 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6336 - fgkEndCapStripConnectionWidth;
6337 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6338 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6339 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6340 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6341 + fgkEndCapInterfaceCardBWidth[1]
6342 + fgkEndCapInterfaceCardBWidth[2];
6343 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6344 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6345 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6346 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6347 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6348 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6349
6350 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6351 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6352 xcardinterfacecontainervertex,
6353 ycardinterfacecontainervertex);
6354 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6355 - fgkEndCapCardElectBoardBackLength[0]));
6356 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6357 + fgkEndCapCardElectBoardBackLength[0]));
6358 TGeoVolume** cardinterfacecontainer;
6359 cardinterfacecontainer = new TGeoVolume*[4];
6360 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6361 interfacecardmothershape,fSSDAir);
6362 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6363 interfacecardmothershape,fSSDAir);
6364 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6365 interfacecardmothershape,fSSDAir);
6366 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6367 interfacecardmothershape,fSSDAir);
6368 /////////////////////////////////
6369 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6370 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6371 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6372 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6373 /////////////////////////////////
6374 TGeoRotation* endcapstripconnectionrot[2];
6375 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6376 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6377 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6378 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6379 * (*endcapstripconnectionrot[0]));
6380 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6381 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6382 -0.5*fgkEndCapCardElectBoardBackThickness,
6383 fgkEndCapCardElectBoardBackWidth[0]
6384 -endcapstripconnectionshape->GetDZ(),
6385 0.5*fgkEndCapCardElectBoardBackLength[0]);
6386 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6387 TGeoTranslation* cardinterfacetrans[9];
6388 TGeoHMatrix* cardinterfacematrix[9];
6389 for(Int_t i=0; i<7; i++){
6390 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6391 + fgkEndCapCardElectBoardBackThickness),
6392 0.0,0.0);
6393 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6394 * (*endcapstripconnectionmatrix));
6395 }
6396 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6397 + fgkEndCapCardElectBoardBackThickness),
6398 0.0,0.0);
6399 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6400 * (*endcapstripconnectionmatrix));
6401 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6402 + fgkEndCapCardElectBoardBackThickness),
6403 0.0,0.0);
6404 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6405 * (*endcapstripconnectionmatrix));
6406
6407 for(Int_t i=0; i<4; i++){
6408 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6409 cardinterfacematrix[7]);
6410 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6411 cardinterfacematrix[8]);
6412 }
6413 TGeoTranslation* mothersupplycardtrans =
6414 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6415 + 2.*fgkEndCapCardJMDConnectorLength[0]
6416 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6417 TGeoHMatrix* mothersupplycardmatrix[7];
6418 Int_t index[4] = {1,1,1,1};
6419 for(Int_t i=0; i<7; i++){
6420 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6421 * (*mothersupplycardtrans));
6422 for(Int_t j=0; j<4; j++){
6423 switch(j){
6424 case 0: //Layer5 EndCap Left Side
6425 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6426 cardinterfacematrix[i]);
6427 if(i!=0){
6428 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6429 mothersupplycardmatrix[i]);
6430 index[j]++;
6431
6432 }
6433 break;
6434 case 1: //Layer5 EndCap Rigth Side
6435 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6436 cardinterfacematrix[i]);
6437 if(i>0&&i<6){
6438 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6439 mothersupplycardmatrix[i]);
6440 index[j]++;
6441 }
6442 break;
6443 case 2: //Layer6 EndCap Left Side
6444 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6445 cardinterfacematrix[i]);
6446 if(i!=6){
6447 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6448 mothersupplycardmatrix[i]);
6449 index[j]++;
6450 }
6451 break;
6452 case 3: //Layer6 EndCap Right Side
6453 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6454 cardinterfacematrix[i]);
6455 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6456 mothersupplycardmatrix[i]);
6457 index[j]++;
6458 break;
6459 }
6460 }
6461 }
6462 // Positioning Interface
6463 TGeoTranslation* motherinterfacecardtrans =
6464 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6465 +0.5*fgkEndCapCardElectBoardBackThickness
6466 -fgkEndCapCardElectBoardLayerThickness
6467 +fgkEndCapStripConnectionThickness,0.,0.);
6468 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6469 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6470 // Positioning Interface Card B
6471 TGeoTranslation* interfacecardBmothertrans =
6472 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6473 + 2.*fgkEndCapStripConnectionThickness
6474 + fgkEndCapCardElectBoardBackThickness,0.,
6475 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6476 - fgkEndCapCardElectBoardBackLength[0]));
6477 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6478 interfacecardBmothertrans);
6479 // Positioning Stiffener
6480 TGeoTranslation* endcapstiffenertrans =
6481 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6482 + 2.0*fgkEndCapStripConnectionThickness
6483 + fgkEndCapInterfaceCardBThickness
6484 + fgkEndCapCardJMDConnectorLength[0]
6485 + stiffenertransx
6486 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6487 endcapstiffenershape->GetDZ()
6488 - 0.5*(fgkEndCapStiffenerLength
6489 - fgkEndCapCardElectBoardBackLength[0]));
6490 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6491 /////////////////////////////////////////////////////////////
6492 // Deallocating memory
6493 /////////////////////////////////////////////////////////////
6494 delete interfacecardBrot;
6495 delete interfacecardBtrans;
6496 delete electboardcardBtrans;
6497 delete electboardcardBrot;
6498 delete jmdconnectorcardBrot;
6499 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6500 delete jmdconnectorot;
6501 delete jmdconnectortrans[1];
6502 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6503 delete cableconnectorcombitrans;
6504 delete electboardbacktrans;
6505 delete electboardbackrot;
6506 delete electlayerrot;
6507 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6508 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6509 delete mothersupplycardtrans;
6510 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6511 /////////////////////////////////////////////////////////////
6512 return cardinterfacecontainer;
6513 }
6514 ////////////////////////////////////////////////////////////////////////////////
6515 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6516 /////////////////////////////////////////////////////////////
6517 // Method returning EndCap Mother Volume
6518 /////////////////////////////////////////////////////////////
6519 const Int_t kendcapcoverplatesmallholenumber = 9;
6520 Double_t endcapmotherorigin[3];
6521 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6522 + 0.5 *(fgkEndCapCoverPlateLength[3]
6523 + 2.0 * fgkEndCapCoverPlateLength[2]);
6524 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6525 - fgkEndCapCoverPlateWidth[2]
6526 - (kendcapcoverplatesmallholenumber-1)
6527 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6528 + 0.5*(fgkEndCapSideCoverLength[2]
6529 + fgkEndCapCoverPlateWidth[1]
6530 - fgkEndCapCoverPlateWidth[0])
6531 - (fgkEndCapCoverPlateWidth[1]
6532 - fgkEndCapCoverPlateWidth[0]);
6533 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6534 + 2.*fgkEndCapCoolingTubeRadiusMax
6535 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6536 + fgkEndCapSideCoverWidth[1]
6537 + fgkEndCapSideCoverThickness
6538 + fgkEndCapKaptonFoilThickness);
6539 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6540 + 2.0* fgkEndCapCoverPlateLength[2]
6541 + 2.0* fgkEndCapSideCoverThickness),
6542 0.5* (fgkEndCapSideCoverLength[2]
6543 + fgkEndCapCoverPlateWidth[1]
6544 - fgkEndCapCoverPlateWidth[0]),
6545 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6546 + fgkEndCapSideCoverWidth[1]
6547 + fgkEndCapSideCoverThickness
6548 + fgkEndCapKaptonFoilThickness),
6549 endcapmotherorigin);
6550 TGeoVolume** endcapassembly;
6551 endcapassembly = new TGeoVolume*[4];
6552 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6553 endcapmothershape,fSSDAir);
6554 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6555 endcapmothershape,fSSDAir);
6556 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6557 endcapmothershape,fSSDAir);
6558 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6559 endcapmothershape,fSSDAir);
6560 /////////////////////////////////
6561 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6562 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6563 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6564 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6565 /////////////////////////////////
6566 /////////////////////////////////////////////////////
6567 // Placing Endcap Cover Plate
6568 /////////////////////////////////////////////////////
6569 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6570 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6571 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6572 TGeoCombiTrans* endcapcoverplatecombitrans =
6573 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6574 endcapcoverplaterot);
6575 TGeoTranslation* endcapcoverplatetrans =
6576 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6577 TGeoHMatrix* endcapcoverplatematrix =
6578 new TGeoHMatrix((*endcapcoverplatetrans)
6579 * (*endcapcoverplatecombitrans));
6580 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6581 /////////////////////////////////////////////////////
6582 // Placing Endcap Side Cover
6583 /////////////////////////////////////////////////////
6584 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6585 TGeoRotation* endcapsidecoverot[2];
6586 TGeoCombiTrans* endcapsidecovercombitrans[3];
6587 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6588 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6589 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6590 - 0.5*(fgkEndCapCoverPlateWidth[0]
6591 - fgkEndCapCoverPlateWidth[2]
6592 - (kendcapcoverplatesmallholenumber-1)
6593 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6594 + 0.*fgkEndCapCoverPlateWidth[0]
6595 + fgkEndCapSideCoverLength[2],
6596 0.5*(fgkEndCapSideCoverThickness
6597 + fgkEndCapCoverPlateThickness)
6598 - 0.5*fgkEndCapCoverPlateThickness,
6599 endcapsidecoverot[0]);
6600 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6601 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6602 0.5*fgkEndCapCoverPlateThickness
6603 -fgkEndCapSideCoverWidth[1],
6604 endcapsidecoverot[1]);
6605 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6606 +fgkEndCapCoverPlateLength[3]
6607 +2.*fgkEndCapCoverPlateLength[2]
6608 +fgkEndCapSideCoverThickness,0.0,
6609 0.5*fgkEndCapCoverPlateThickness
6610 -fgkEndCapSideCoverWidth[1],
6611 endcapsidecoverot[1]);
6612 TGeoHMatrix* endcapsidecovermatrix[2];
6613 for(Int_t i=0; i<2; i++){
6614 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6615 * (*endcapsidecovercombitrans[0]));
6616 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6617 endcapsidecovermatrix[i]);
6618 }
6619 /////////////////////////////////////////////////////
6620 // Placing Endcap Cooling Tube
6621 /////////////////////////////////////////////////////
6622 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6623 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6624 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6625 TGeoCombiTrans* endcapccolingtubecombitrans
6626 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6627 + fgkEndCapCoolingTubeAxialRadius[1])
6628 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6629 - fgkEndCapCoolingTubeToCoverSide,
6630 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6631 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6632 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6633 endcapccolingtubecombitrans);
6634 /////////////////////////////////////////////////////
6635 // Placing Screws
6636 /////////////////////////////////////////////////////
6637 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6638 fgkEndCapCoverPlateScrewRadiusMin};
6639 Int_t screwcoverplatedgesnumber[2] = {20,20};
6640 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6641 fgkEndCapCoverPlateThickness
6642 + fgkEndCapCoolingTubeRadiusMax};
851c0ce3 6643 TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
9b0c60ab 6644 screwcoverplatedgesnumber,
6645 screwcoverplatesection);
6646 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6647 screwcoverplateshape,
6648 fSSDCoolingTubePhynox);
6649 screwcoverplate->SetLineColor(12);
6650 Double_t transx[4] = {0,
6651 fgkEndCapCoverPlateSmallHoleSeparation[0],
6652 fgkEndCapCoverPlateSmallHoleSeparation[0]
6653 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6654 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6655 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6656 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6657// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6658 TGeoTranslation*** endcapcoverplatescrewtrans;
6659 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6660 Int_t index = 0;
6661 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6662 endcapcoverplatescrewtrans[i] =
6663 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6664 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6665 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6666 if(index==1||index==9||index==28||index==36){
6667 endcapcoverplatescrewtrans[i][j] =
6668 new TGeoTranslation(transx[i],
6669 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6670 fgkEndCapSideCoverThickness);
6671 }
6672 else{
6673 endcapcoverplatescrewtrans[i][j] =
6674 new TGeoTranslation(transx[i],
6675 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6676 0.);
6677 }
6678 if(index!=19)
6679 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6680 endcapcoverplatescrewtrans[i][j]);
6681 }
6682 }
6683 /////////////////////////////////////////////////////
6684 // Placing Cover Plate Clips
6685 /////////////////////////////////////////////////////
6686 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6687 0.5*fgkEndCapCoverPlateClipWidth,
6688 0.5*fgkEndCapSideCoverThickness);
6689 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6690 endcapcoverplateclipshape,
6691 fSSDCoolingTubePhynox);
6692 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6693 0.5*fgkEndCapCoverPlateDownClipWidth,
6694 0.5*fgkEndCapSideCoverThickness);
6695 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6696 endcapcoverplatedownclipshape,
6697 fSSDCoolingTubePhynox);
6698 TGeoTranslation* endcapcoverplatecliptrans[4];
6699 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6700 - fgkEndCapCoverPlateLength[0]
6701 - fgkEndCapSideCoverThickness,
6702 0.0,
6703 0.5*(fgkEndCapSideCoverThickness
6704 + fgkEndCapCoverPlateThickness));
6705 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6706 - fgkEndCapCoverPlateLength[0]
6707 - fgkEndCapSideCoverThickness,
6708 (kendcapcoverplatescrewnumber[1]-1)
6709 * fgkEndCapSideCoverWidth[5],
6710 0.5*(fgkEndCapSideCoverThickness
6711 + fgkEndCapCoverPlateThickness));
6712 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6713 - fgkEndCapCoverPlateLength[0]
6714 + fgkEndCapCoverPlateLength[1]
6715 + 2.*fgkEndCapCoverPlateLength[0]
6716 - fgkEndCapCoverPlateClipLength
6717 + fgkEndCapSideCoverThickness,
6718 0.0,
6719 0.5*(fgkEndCapSideCoverThickness
6720 + fgkEndCapCoverPlateThickness));
6721 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6722 - fgkEndCapCoverPlateLength[0]
6723 + fgkEndCapCoverPlateLength[1]
6724 + 2.*fgkEndCapCoverPlateLength[0]
6725 - fgkEndCapCoverPlateClipLength
6726 + fgkEndCapSideCoverThickness,
6727 (kendcapcoverplatescrewnumber[1]-1)
6728 * fgkEndCapSideCoverWidth[5],
6729 0.5*(fgkEndCapSideCoverThickness
6730 + fgkEndCapCoverPlateThickness));
6731 endcapcoverplateclip->SetLineColor(fColorPhynox);
6732 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6733 for(Int_t i=0; i<4; i++)
6734 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6735 endcapcoverplatecliptrans[i]);
6736 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6737 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6738 - fgkEndCapCoverPlateLength[0]
6739 - fgkEndCapSideCoverThickness,
6740 0.5*(fgkEndCapCoverPlateDownClipWidth
6741 - fgkEndCapCoverPlateClipWidth),
6742 0.5*(fgkEndCapSideCoverThickness
6743 + fgkEndCapCoverPlateThickness)
6744 - fgkEndCapSideCoverWidth[1]
6745 - fgkEndCapSideCoverThickness);
6746 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6747 - fgkEndCapCoverPlateLength[0]
6748 - fgkEndCapSideCoverThickness,
6749 0.5*(fgkEndCapCoverPlateDownClipWidth
6750 - fgkEndCapCoverPlateClipWidth)
6751 + fgkEndCapSideCoverLength[2]
6752 - fgkEndCapCoverPlateDownClipWidth,
6753 0.5*(fgkEndCapSideCoverThickness
6754 + fgkEndCapCoverPlateThickness)
6755 - fgkEndCapSideCoverWidth[1]
6756 - fgkEndCapSideCoverThickness);
6757 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6758 - fgkEndCapCoverPlateLength[0]
6759 + fgkEndCapSideCoverThickness
6760 + fgkEndCapCoverPlateLength[1]
6761 + 2.0*fgkEndCapCoverPlateLength[0]
6762 - fgkEndCapCoverPlateDownClipLength,
6763 0.5*(fgkEndCapCoverPlateDownClipWidth
6764 - fgkEndCapCoverPlateClipWidth),
6765 0.5*(fgkEndCapSideCoverThickness
6766 + fgkEndCapCoverPlateThickness)
6767 - fgkEndCapSideCoverWidth[1]
6768 - fgkEndCapSideCoverThickness);
6769 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6770 - fgkEndCapCoverPlateLength[0]
6771 + fgkEndCapSideCoverThickness
6772 + fgkEndCapCoverPlateLength[1]
6773 + 2.0*fgkEndCapCoverPlateLength[0]
6774 - fgkEndCapCoverPlateDownClipLength,
6775 0.5*(fgkEndCapCoverPlateDownClipWidth
6776 - fgkEndCapCoverPlateClipWidth)
6777 + fgkEndCapSideCoverLength[2]
6778 - fgkEndCapCoverPlateDownClipWidth,
6779 0.5*(fgkEndCapSideCoverThickness
6780 + fgkEndCapCoverPlateThickness)
6781 - fgkEndCapSideCoverWidth[1]
6782 - fgkEndCapSideCoverThickness);
6783 for(Int_t i=0; i<4; i++)
6784 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6785 endcapcoverplatedowncliptrans[i]);
6786 /////////////////////////////////////////////////////
6787 // Placing Kapton Foil
6788 /////////////////////////////////////////////////////
6789 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6790 0.5*fgkEndCapKaptonFoilWidth,
6791 0.5*fgkEndCapKaptonFoilThickness);
6792 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6793 endcapkaptonfoilshape,
6794 fSSDKaptonFlexMedium);
6795 endcapkaptonfoil->SetLineColor(8);
6796 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6797 0.5*fgkEndCapKaptonFoilWidth
6798 - 0.5*fgkEndCapCoverPlateClipWidth,
6799 0.5*fgkEndCapCoverPlateThickness
6800 - 0.5*fgkEndCapKaptonFoilThickness
6801 - fgkEndCapSideCoverWidth[1]
6802 - fgkEndCapSideCoverThickness);
6803 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6804 /////////////////////////////////////////////////////////////
6805 // Placing Electronic Tubes
6806 /////////////////////////////////////////////////////////////
6807 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6808 - fgkEndCapInterfaceCardBThickness
6809 - 9.*fgkEndCapStripConnectionThickness
6810 - 8.*fgkEndCapCardElectBoardBackThickness,
6811 fgkEndCapKaptonFoilWidth
6812 - fgkEndCapInterfaceCardBThickness
6813 - 9.*fgkEndCapStripConnectionThickness
6814 - 8.*fgkEndCapCardElectBoardBackThickness
6815 - fgkEndCapInterfaceElectBoardCardBThickness};
6816 TGeoVolume* endcapeffectivecables[2];
6817 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6818 fgkEndCapEffectiveCableRadiusMax,
6819 endcapeffectivecableswidth[0],
6820 10,"EndCapEffectiveCables1");
6821 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6822 fgkEndCapEffectiveCableRadiusMax,
6823 endcapeffectivecableswidth[1],
6824 25,"EndCapEffectiveCables2");
6825 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6826 TGeoTranslation* endcapeffectivecablestrans[2];
6827 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6828 - 0.5*endcapeffectivecableswidth[0]
6829 - 0.5*(fgkEndCapCoverPlateWidth[0]
6830 - fgkEndCapCoverPlateWidth[2]
6831 - (kendcapcoverplatesmallholenumber-1)
6832 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6833 + fgkEndCapSideCoverLength[2],
6834 - 0.5*fgkEndCapCoverPlateThickness
6835 - (fgkEndCapCardElectBoardBackWidth[0]
6836 - fgkEndCapInterfaceCardBWidth[0]
6837 - fgkEndCapInterfaceCardBWidth[1]));
6838 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6839 - 0.5*endcapeffectivecableswidth[1]
6840 - 0.5*(fgkEndCapCoverPlateWidth[0]
6841 - fgkEndCapCoverPlateWidth[2]
6842 - (kendcapcoverplatesmallholenumber-1)
6843 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6844 + fgkEndCapSideCoverLength[2],
6845 - 0.5*fgkEndCapCoverPlateThickness
6846 - (fgkEndCapCardElectBoardBackWidth[0]
6847 - fgkEndCapInterfaceCardBWidth[0])
6848 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6849 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6850 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6851 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6852 *endcapeffectivecablesrot);
6853 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6854 *endcapeffectivecablesrot);
47f8de53 6855// for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6856// endcapeffectivecablescombitrans[0]);
9b0c60ab 6857 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6858 endcapeffectivecablescombitrans[1]);
6859 /////////////////////////////////////////////////////////////
6860 // Placing End Cap Cards
6861 /////////////////////////////////////////////////////////////
6862 TGeoVolume** endcapcards = GetEndCapCards();
6863 TGeoRotation* endcapcardsrot[2];
6864 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6865 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6866 TGeoTranslation* endcapcardstrans[2];
6867 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6868 - fgkEndCapCardElectBoardBackLength[0]));
6869 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6870 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6871 TGeoHMatrix* endcapcardsmatrix[2];
6872 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6873 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6874 - fgkEndCapCardJMDConnectorLength[0]
6875 - fgkEndCapInterfaceCardBThickness
6876 - 9.*fgkEndCapStripConnectionThickness
6877 - 8.*fgkEndCapCardElectBoardBackThickness;
6878 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6879 - fgkEndCapCoverPlateLength[0]
6880 + 0.5 * (fgkEndCapCoverPlateLength[3]
6881 + 2.0 * fgkEndCapCoverPlateLength[2]),
6882 - stiffenertransx-fgkEndCapStiffenerWidth
6883 - fgkEndCapCardJMDConnectorLength[0]
6884 - fgkEndCapInterfaceCardBThickness
6885 - 2.0 * fgkEndCapStripConnectionThickness
6886 - 1.5 * fgkEndCapInterfaceCardBThickness
6887 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6888 - fgkEndCapCoverPlateWidth[2]
6889 - (kendcapcoverplatesmallholenumber-1)
6890 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6891 + fgkEndCapKaptonFoilWidth,
6892 0.5*fgkEndCapCoverPlateThickness
6893 - fgkEndCapSideCoverWidth[1]);
6894 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6895 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6896 /////////////////////////////////////////////////////////////
6897 // Deallocating memory
6898 /////////////////////////////////////////////////////////////
6899 delete endcapcoverplaterot;
6900 delete endcapcoverplatecombitrans;
6901 delete endcapcoverplatetrans;
6902 for(Int_t i=0; i<3; i++){
6903 delete endcapsidecovercombitrans[i];
6904 if(i<2) delete endcapsidecoverot[i];
6905 }
6906 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6907 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6908 delete endcapcardsmatrix[0];
6909 return endcapassembly;
6910 }
6911 ////////////////////////////////////////////////////////////////////////////////
6912 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6913 Double_t radiusmax,
6914 Double_t width,
6915 Int_t ncables,
a6e0ebfe 6916 const char* volname){
9b0c60ab 6917 /////////////////////////////////////////////////////////////
6918 // Generating EndCap High Voltage Tubes
6919 /////////////////////////////////////////////////////////////
6920 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
60e55aee 6921 Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6922
9b0c60ab 6923 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6924 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6925 effectiveouteradius,0.5*width);
6926 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6927 effectiveinnertubeshape,
6928 fSSDStiffenerConnectorMedium);
6929 effectiveinnertube->SetLineColor(41);
6930 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6931 effectiveoutertubeshape,
6932 fSSDKaptonChipCableMedium);
6933 effectiveoutertube->SetLineColor(39);
6934 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6935 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6936 effectivemothertube->AddNode(effectiveinnertube,1);
6937 effectivemothertube->AddNode(effectiveoutertube,1);
6938 return effectivemothertube;
6939 }
6940 ////////////////////////////////////////////////////////////////////////////////
6941 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6942 /////////////////////////////////////////////////////////////
6943 // Generating EndCap Support Layer 5 and Layer 6
6944 /////////////////////////////////////////////////////////////
6945 const Int_t knedges = 5;
6946 ///////////////////////////////////////////////
6947 // Setting the vertices for TGeoXtru Up Volume
6948 ///////////////////////////////////////////////
6949 const Int_t klayernumber = 2;
6950 Double_t xupvertex[klayernumber][knedges+3];
6951 Double_t yupvertex[klayernumber][knedges+3];
6952 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6953 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6954 Double_t middlepsi[klayernumber] = {0.0,0.0};
6955 for(Int_t i=0; i<klayernumber; i++){
6956 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6957 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6958 xupvertex[i][2] = -xupvertex[i][1];
6959 xupvertex[i][3] = -xupvertex[i][0];
6960
6961 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6962 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6963 yupvertex[i][2] = yupvertex[i][1];
6964 yupvertex[i][3] = yupvertex[i][0];
6965
6966 middledgeangle[i] = upedgeangle[i]/knedges;
6967 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6968 for(Int_t j=1; j<knedges; j++){
6969 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6970 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6971 }
6972 }
6973 ////////////////////////////////////
6974 // Generating Up TGeoXtru
6975 ////////////////////////////////////
6976 TGeoXtru* upendcapsupportshape[klayernumber];
6977 TGeoVolume* upendcapsupport[klayernumber];
a3f8715e 6978 char upendcapsupportname[100];
9b0c60ab 6979 for(Int_t i=0; i<klayernumber; i++){
6980 upendcapsupportshape[i] = new TGeoXtru(2);
6981 sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6982 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6983 upendcapsupportshape[i]->DefineSection(0,0.);
6984 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6985 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 6986 fSSDSupportRingAl);
9b0c60ab 6987 upendcapsupport[i]->SetLineColor(5);
6988 }
6989 ///////////////////////////////////////////////
6990 // Setting the vertices for TGeoXtru Down Volume
6991 ///////////////////////////////////////////////
6992 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6993 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6994 for(Int_t i=0; i<klayernumber; i++){
6995 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6996 xdownvertex[i][1] = xupvertex[i][0];
6997 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6998 ydownvertex[i][1] = yupvertex[i][0];
6999 for(Int_t j=0; j<knedges; j++){
7000 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
7001 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
7002 }
7003 for(Int_t j=0; j<knedges; j++){
7004 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
7005 * CosD(middlepsi[i]+j*middledgeangle[i]);
7006 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
7007 * SinD(middlepsi[i]+j*middledgeangle[i]);
7008 }
7009 }
7010 ////////////////////////////////////
7011 // Generating Down TGeoXtru
7012 ////////////////////////////////////
7013 TGeoXtru* downendcapsupportshape[klayernumber];
7014 TGeoVolume* downendcapsupport[klayernumber];
a3f8715e 7015 char downendcapsupportname[100];
9b0c60ab 7016 for(Int_t i=0; i<klayernumber; i++){
7017 downendcapsupportshape[i] = new TGeoXtru(2);
7018 sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
7019 downendcapsupportshape[i] = new TGeoXtru(2);
7020 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
7021 if(i==0){
7022 downendcapsupportshape[i]->DefineSection(0,0.);
7023 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
7024 }
7025 else{
7026 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
7027 - fgkEndCapSupportLowWidth[i]);
7028 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
7029 }
7030 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 7031 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 7032 downendcapsupport[i]->SetLineColor(5);
7033 }
7034 ///////////////////////////////////////////////
7035 // Setting TGeoPgon Volume
7036 ///////////////////////////////////////////////
7037 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
7038 fgkSSDLay6LadderNumber};
7039 TGeoPgon* endcapsupportmothershape[klayernumber];
7040 TGeoVolume** endcapsupportmother;
7041 endcapsupportmother = new TGeoVolume*[klayernumber];
a3f8715e 7042 char endcapsupportmothername[100];
9b0c60ab 7043 for(Int_t i=0; i<klayernumber; i++){
7044 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7045 sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
7046 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
7047 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
7048 ydownvertex[i][0],yupvertex[i][1]);
7049 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 7050 fSSDAir);
9b0c60ab 7051 }
7052 ////////////////////////////////////
7053 TGeoRotation** endcapsupportrot[klayernumber];
7054 for(Int_t i=0; i<2; i++){
7055 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
7056 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7057 endcapsupportrot[i][j] = new TGeoRotation();
7058 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
7059 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
7060 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
7061 }
7062 }
7063 return endcapsupportmother;
7064 }
7065 ////////////////////////////////////////////////////////////////////////////////
7066 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
7067 /////////////////////////////////////////////////////////////
7068 // Setting End Cap Support Layer 5 and 6.
7069 /////////////////////////////////////////////////////////////
7070 const Int_t kendcapcoverplatesmallholenumber = 9;
7071 const Int_t klayernumber = 2;
7072 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
7073 fgkSSDLay6LadderNumber};
7074 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
7075 360.0/kssdlayladdernumber[1]};
7076 TGeoVolume** endcapsupport = EndCapSupport();
7077 TGeoVolume** endcapassembly = GetEndCapAssembly();
7078 TGeoPgon* endcapsupportshape[klayernumber];
7079 Double_t* radiusmin[klayernumber];
7080 Double_t* radiusmax[klayernumber];
7081 for(Int_t i=0; i<klayernumber; i++){
7082 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
7083 radiusmin[i] = endcapsupportshape[i]->GetRmin();
7084 radiusmax[i] = endcapsupportshape[i]->GetRmax();
7085 }
7086 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
7087 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
7088 endcapassemblyshape->GetDY(),
7089 endcapassemblyshape->GetDZ()};
7090 ///////////////////////////////////////////////
7091 // Setting TGeoPgon Volume for Mother Container
7092 ///////////////////////////////////////////////
7093 TGeoPgon* endcapsupportsystemshape[klayernumber];
a3f8715e 7094 char endcapsupportsystemothername[100];
9b0c60ab 7095 for(Int_t i=0; i<klayernumber; i++){
7096 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7097 sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
7098 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
7099 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
7100 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7101 +2.*endcapassemblycenter[2])
7102 /CosD(0.5*upedgeangle[i]));
7103 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7104 -(fgkEndCapCoverPlateWidth[1]
7105 - fgkEndCapCoverPlateWidth[0]),
7106 *radiusmin[i],
7107 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7108 +2.*endcapassemblycenter[2])
7109 /CosD(0.5*upedgeangle[i]));
7110 }
e5bf64ae 7111 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 7112 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7113 endcapsupportsystemshape[0],fSSDAir);
7114 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7115 endcapsupportsystemshape[0],fSSDAir);
7116 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7117 endcapsupportsystemshape[1],fSSDAir);
7118 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7119 endcapsupportsystemshape[1],fSSDAir);
7120 ///////////////////////////////////////////////
7121 TGeoTranslation* endcapassemblytrans[klayernumber];
7122 for(Int_t i=0; i<klayernumber; i++)
7123 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7124 - fgkEndCapSideCoverThickness
7125 + endcapassemblycenter[0],
7126 - 0.5*fgkEndCapCoverPlateThickness
7127 - 2.0*fgkEndCapCoolingTubeRadiusMax
7128 + 2.0*endcapassemblycenter[2]
7129 + 0.5*fgkEndCapSupportLength[i]
7130 / TanD(0.5*upedgeangle[i]),
7131 0.5*(fgkEndCapCoverPlateWidth[0]
7132 - fgkEndCapCoverPlateWidth[2]
7133 - (kendcapcoverplatesmallholenumber-1)
7134 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
7135 TGeoRotation** endcapassemblyrot[klayernumber];
7136 TGeoHMatrix** endcapassemblymatrix[klayernumber];
7137 for(Int_t i=0; i<klayernumber; i++){
7138 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7139 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7140 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7141 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7142 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7143 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7144 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7145 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7146 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7147 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7148 }
7149 }
7150 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7151 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7152 for(Int_t i=0; i<2*klayernumber; i++){
7153 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7154 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7155 endcapassemblymatrix[1][j+2]);
7156 }
7157 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7158 }
7159 /////////////////////////////////////////////////////////////
7160 // Deallocating memory
7161 /////////////////////////////////////////////////////////////
7162 for(Int_t i=0; i<klayernumber; i++){
7163 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7164 delete endcapassemblyrot[i][j];
7165 }
7b208ef4 7166 delete [] endcapassemblyrot[i];
9b0c60ab 7167 delete endcapassemblymatrix[i][0];
7168 delete endcapassemblymatrix[i][1];
7169 }
7170 /////////////////////////////////////////////////////////////
7171 }
7172 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7173 /////////////////////////////////////////////////////////////
7174 // Setting End Cap Support + End Cap Assembly of Layer 5.
7175 /////////////////////////////////////////////////////////////
7176 if (! moth) {
160835d5 7177 AliError("Can't insert end cap support of layer5, mother is null!\n");
9b0c60ab 7178 return;
7179 };
e5bf64ae 7180 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7181 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7182 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7183 fgkEndCapSupportCenterLay5ITSPosition
7184 + fgkEndCapSupportCenterLay5Position
7185 - fgkEndCapSideCoverLength[2]);
7186 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7187 fgkEndCapSideCoverLength[2]
7188 - fgkEndCapSupportCenterLay5Position
7189 - fgkEndCapSupportCenterLay5ITSPosition);
7190 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7191 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7192 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7193 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7194 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7195 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7196 /////////////////////////////////////////////////////////////
7197 // Deallocating memory
7198 /////////////////////////////////////////////////////////////
7199 delete endcapsupportsystemrot;
7200 delete endcapsupportsystemITSCentertrans[1];
7201 }
7202 /////////////////////////////////////////////////////////////
7203 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7204 /////////////////////////////////////////////////////////////
7205 // Setting End Cap Support + End Cap Assembly of Layer 6.
7206 /////////////////////////////////////////////////////////////
7207 if (! moth) {
160835d5 7208 AliError("Can't insert end cap support of layer6, mother is null!\n");
9b0c60ab 7209 return;
7210 };
e5bf64ae 7211 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7212 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7213 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7214 fgkEndCapSupportCenterLay6ITSPosition
7215 + fgkEndCapSupportCenterLay6Position
7216 - fgkEndCapSideCoverLength[2]);
7217 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7218 fgkEndCapSideCoverLength[2]
7219 - fgkEndCapSupportCenterLay6Position
7220 - fgkEndCapSupportCenterLay6ITSPosition);
7221 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7222 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7223 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7224 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7225 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7226 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7227 /////////////////////////////////////////////////////////////
7228 // Deallocating memory
7229 /////////////////////////////////////////////////////////////
7230 delete endcapsupportsystemrot;
7231 delete endcapsupportsystemITSCentertrans[1];
7232 }
7233 ////////////////////////////////////////////////////////////////////////////////
7234 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7235 /////////////////////////////////////////////////////////////
7236 // Setting Ladder Support of Layer 5.
7237 /////////////////////////////////////////////////////////////
7238 if (! moth) {
160835d5 7239 AliError("Can't insert ladder lupport of layer5, mother is null!\n");
9b0c60ab 7240 return;
7241 };
7242 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7243 fMotherVol = moth;
7244 TGeoTranslation* centerITSRingSupportLay5trans[2];
7245 for(Int_t i=0; i<2; i++){
7246 centerITSRingSupportLay5trans[i] =
7247 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7248 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7249 }
7250 }
7251 ////////////////////////////////////////////////////////////////////////////////
7252 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7253 /////////////////////////////////////////////////////////////
7254 // Setting Ladder Support of Layer 6.
7255 /////////////////////////////////////////////////////////////
7256 if (! moth) {
160835d5 7257 AliError("Can't insert ladder lupport of layer6, mother is null!\n");
9b0c60ab 7258 return;
7259 };
7260 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7261 fMotherVol = moth;
7262 TGeoTranslation* centerITSRingSupportLay6trans[2];
7263 for(Int_t i=0; i<2; i++){
7264 centerITSRingSupportLay6trans[i] =
7265 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7266 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7267 }
7268 }
7269 ////////////////////////////////////////////////////////////////////////////////
47f8de53 7270 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7271 /////////////////////////////////////////////////////////////
7272 // Setting Ladder Support of Layer 6.
7273 /////////////////////////////////////////////////////////////
7274 if (! moth) {
160835d5 7275 AliError("Can't insert SSD Cone, mother is null!\n");
47f8de53 7276 return;
7277 };
7278 if(!fSSDCone) SetSSDCone();
7279 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7280 + fgkSSDCentralAL3SupportLength);
7281 moth->AddNode(fSSDCone,1,ssdconetrans);
7282}
7283 ////////////////////////////////////////////////////////////////////////////////
7284 void AliITSv11GeometrySSD::SetSSDCone(){
7285 /////////////////////////////////////////////////////////////
7286 // Method generating SSDCone
7287 /////////////////////////////////////////////////////////////
7288 if(!fCreateMaterials) CreateMaterials();
7289 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7290 Double_t ssdpconesectionradiusmax[16];
7291 Double_t ssdpconesectionradiusmin[16];
7292 Double_t ssdpconezsection[16];
7293 TGeoPcon* ssdpconelittleholeshape[8];
7294 TGeoVolume* ssdpconelittlehole[8];
7295 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7296 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7297 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7298 / SinD(fgkSSDPConeAngle)
7299 + ssdpconesectionradiusmin[0];
7300 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7301 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7302 / SinD(fgkSSDPConeAngle);
7303 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7304 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7305 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7306 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7307 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7308 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7309 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7310 ssdpconelittlehole[0]->SetLineColor(4);
7311 /////////////////////////////////////////////////////////////
7312 ssdpconezsection[2] = ssdpconezsection[1];
7313 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7314 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7315 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7316 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7317 / SinD(fgkSSDPConeAngle);
7318 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7319 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7320 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7321 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7322 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7323 * TMath::RadToDeg();
7324 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7325 60.-ssdpconelittleholeangle,2);
7326 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7327 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7328 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7329 ssdpconelittlehole[1]->SetLineColor(4);
7330 TGeoRotation* ssdconelittleholerot[6];
7331 for(Int_t i=0; i<6; i++){
7332 ssdconelittleholerot[i] = new TGeoRotation();
7333 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7334 }
7335 /////////////////////////////////////////////////////////////
7336 ssdpconezsection[4] = ssdpconezsection[3];
7337 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7338 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7339 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7340 * CosD(fgkSSDPConeAngle)
7341 / SinD(fgkSSDPConeAngle);
7342 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7343 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7344 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7345 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7346 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7347 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7348 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7349 ssdpconelittlehole[2]->SetLineColor(4);
7350 ///////////////////////////////////////////////////
7351 ssdpconezsection[6] = ssdpconezsection[5];
7352 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7353 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7354 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7355 -ssdpconezsection[0]
7356 * CosD(fgkSSDPConeAngle)
7357 / SinD(fgkSSDPConeAngle);
7358 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7359 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7360 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7361 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7362 * TMath::RadToDeg();
7363 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7364 45.-ssdpconemiddleholeangle,2);
7365 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7366 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7367 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7368 ssdpconelittlehole[3]->SetLineColor(4);
7369 TGeoRotation* ssdconemiddleholerot[8];
7370 for(Int_t i=0; i<8; i++){
7371 ssdconemiddleholerot[i] = new TGeoRotation();
7372 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7373 }
7374 /////////////////////////////////////////////////////////////
7375 ssdpconezsection[8] = ssdpconezsection[7];
7376 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7377 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7378 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7379 * CosD(fgkSSDPConeAngle)
7380 / SinD(fgkSSDPConeAngle);
7381 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7382 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7383 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7384 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7385 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7386 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7387 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7388 ssdpconelittlehole[4]->SetLineColor(4);
7389 /////////////////////////////////////////////////////////////
7390 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7391 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7392 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7393 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7394 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7395 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7396 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7397 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7398 * TMath::RadToDeg();
7399 ssdpconezsection[10] = ssdpconezsection[9];
7400 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7401 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7402 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7403 * CosD(fgkSSDPConeAngle)
7404 / SinD(fgkSSDPConeAngle);
7405 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7406 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7407 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7408 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7409 ssdpconetrapezoidsectionangle,2);
7410 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7411 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7412 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7413 ssdpconelittlehole[5]->SetLineColor(4);
7414 TGeoRotation* ssdconeupradiusrot[8];
7415 for(Int_t i=0; i<8; i++){
7416 ssdconeupradiusrot[i] = new TGeoRotation();
7417 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7418 }
7419 /////////////////////////////////////////////////////////////
7420 ssdpconezsection[12] = ssdpconezsection[11];
7421 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7422 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7423 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7424 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7425 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7426 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7427 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7428 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7429 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7430 ssdpconelittlehole[6]->SetLineColor(4);
7431 /////////////////////////////////////////////////////////////
7432 ssdpconezsection[14] = 0.0;
7433 ssdpconezsection[15] = ssdpconezsection[0];
7434 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7435 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7436 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7437 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7438 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7439 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7440 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7441 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7442 ssdpconelittlehole[7]->SetLineColor(4);
7443 /////////////////////////////////////////////////////////////
7444 TGeoTube* ssdtubeconeshape[2];
7445 TGeoVolume* ssdtubecone[2];
7446 TGeoTranslation* ssdtubeconetrans[2];
7447 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7448 fgkSSDPConeExternalRadius,
7449 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7450 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7451 0.5*ssdpconezsection[0]);
7452 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7453 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7454 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7455 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7456 + ssdpconezsection[13]);
7457 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7458 ssdtubecone[0]->SetLineColor(4);
7459 ssdtubecone[1]->SetLineColor(4);
7460 /////////////////////////////////////////////////////////////
7461 // Mother Volume Container
7462 /////////////////////////////////////////////////////////////
7463 Double_t ssdconemotherradiusmin[8];
7464 Double_t ssdconemotherradiusmax[8];
7465 Double_t ssdconemothersection[8];
7466 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7467 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7468 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7469 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7470 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7471 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7472 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7473 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7474 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7475 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7476 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7477 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7478 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7479 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7480 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7481 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7482 ssdconemothersection[0] = 0.0;
7483 ssdconemothersection[1] = ssdpconezsection[0];
7484 ssdconemothersection[2] = ssdpconezsection[0];
7485 ssdconemothersection[3] = ssdpconezsection[11];
7486 ssdconemothersection[4] = ssdpconezsection[11];
7487 ssdconemothersection[5] = ssdpconezsection[13];
7488 ssdconemothersection[6] = ssdpconezsection[13];
7489 ssdconemothersection[7] = fgkSSDPConeLength;
7490 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7491 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7492 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7493 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7494 /////////////////////////////////////////////////////////////
7495 //Placing the Volumes into Mother
7496 /////////////////////////////////////////////////////////////
7497 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7498 for(Int_t i=0; i<6; i++){
7499 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7500 }
7501 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7502 for(Int_t i=0; i<8; i++){
7503 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7504 }
7505 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7506 for(Int_t i=0; i<8; i++){
7507 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7508 }
7509 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7510 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7511 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7512 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7513 /////////////////////////////////////////////////////////////
7514 // ITS General Support
7515 /////////////////////////////////////////////////////////////
7516 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7517 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7518 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7519 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7520 - fgkSSDCentralAL3SupportLength);
7521 ssdcentralsupport->SetLineColor(4);
7522 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7523 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7524 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7525 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7526 TGeoTranslation* ssdcentralal3supportrans[3];
7527 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7528 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7529 - 1.25*fgkSSDCentralAL3SupportLength);
7530 ssdcentralal3support->SetLineColor(4);
7531 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7532 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7533 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7534 Double_t ssdpconcentralradiusmin[2];
7535 Double_t ssdpconcentralradiusmax[2];
7536 Double_t ssdpconcentralsection[2];
7537 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7538 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7539 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7540 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7541 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7542 ssdpconcentralsection[1] = 0.;
7543 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7544 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7545 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7546 ssdpconcentralal3->SetLineColor(4);
7547 fSSDCone->AddNode(ssdpconcentralal3,1);
7548 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7549 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7550 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7551 -2.*fgkSSDCentralAL3SupportLength);
7552 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7553 *ssdcentralal3supportrot);
7554 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7555 TGeoRotation* ssdconemotherot = new TGeoRotation();
7556 ssdconemotherot->SetAngles(90.,180.,-90.);
7557 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7558 -2.*fgkSSDCentralAL3SupportLength);
7559 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7560 fSSDCone->AddNode(ssdconemother,1);
7561 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7562 /////////////////////////////////////////////////////////////
7563 // Deallocating memory
7564 /////////////////////////////////////////////////////////////
7565 delete ssdcentralal3supportrot;
7566 delete ssdcentralal3supportrans[2];
7567 delete ssdconemotherot;
7568 delete ssdconemothertrans;
7569 /////////////////////////////////////////////////////////////
7570 }
fcfbdd23 7571 ////////////////////////////////////////////////////////////////////////////////
7572 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7573 /////////////////////////////////////////////////////////////
7574 // Setting SSD Cables
7575 /////////////////////////////////////////////////////////////
7576 if (! moth) {
160835d5 7577 AliError("Can't insert SSD Cables, mother is null!\n");
fcfbdd23 7578 return;
7579 };
7580 TGeoVolume* ssdcables = SetSSDCables();
7581 moth->AddNode(ssdcables,1);
7582}
47f8de53 7583 ////////////////////////////////////////////////////////////////////////////////
7584 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7585 /////////////////////////////////////////////////////////////
7586 // Method generating SSDCables
7587 /////////////////////////////////////////////////////////////
7588 // SSD Layer 5 Cables
7589 //////////////////////////////////////////////////////////////////////////////////////////////////
7590 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7591 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
fcfbdd23 7592 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
47f8de53 7593 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7594 //////////////////////////////////////////////////////////////////////////////////////////////////
7595 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+fgkSSDCablesLay5TubeRadiusMin;
7596 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7597 - fgkSSDLowerPConeRadius)
7598 * TanD(fgkSSDPConeAngle);
7599 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7600 + fgkEndCapSupportCenterLay5Position
7601 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7602 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7603 - ssdcableslay5startconedistance;
7604 ssdcablelay5rightsidelength *= ssdcablesfactor;
7605 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+fgkSSDCablesLay5RightSideHeight;
7606 TGeoTube* ssdcablelay5rightubeshape = new TGeoTube(ssdcableslay5rigthsideradiusmin,
7607 ssdcableslay5rightsideradiusmax,
7608 0.5*ssdcablelay5rightsidelength);
7609 TGeoVolume* ssdcablelay5righttube = new TGeoVolume("SSDCableLay5RightSideTube",
7610 ssdcablelay5rightubeshape,
7611 fSSDCopper);
7612 ssdcablelay5righttube->SetLineColor(9);
7613 TGeoTranslation* ssdcablelay5rightrans =
7614 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7615 + fgkEndCapSupportCenterLay5Position
7616 + 0.5*ssdcablelay5rightsidelength);
7617 ////////////////////////////////////
7618 // Double_t cablescapacity[20];
7619 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7620 ////////////////////////////////////
7621 ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7622 ////////////////////////////////////
7623 // TGeoPCone Volumes
7624 ///////////////////////////////////
7625 TGeoPcon* ssdcableslay5pconshape[3];
7626 TGeoVolume* ssdcableslay5pcon[3];
7627 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7628 Double_t ssdcableslay5pconzsection[6];
7629 Double_t ssdcableslay5pconrmin[6];
7630 Double_t ssdcableslay5pconrmax[6];
7631 ssdcableslay5pconrmin[0] = ssdcablelay5rightubeshape->GetRmin();
7632 ssdcableslay5pconrmax[0] = ssdcablelay5rightubeshape->GetRmax();
7633 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7634 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+fgkSSDCablesLay5RightSideHeight;
7635 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7636 + fgkEndCapSupportCenterLay5Position
7637 + 2.*ssdcablelay5rightubeshape->GetDz();
7638 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7639 + fgkSSDCentralAL3SupportLength
7640 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7641 * TanD(fgkSSDPConeAngle);
7642 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7643 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7644 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7645 ssdcableslay5pconshape[0],fSSDCopper);
7646 ssdcableslay5pcon[0]->SetLineColor(9);
7647 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7648////////////////////////////////////
7649// cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7650////////////////////////////////////
7651 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7652 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7653 + fgkSSDCentralAL3SupportLength
7654 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7655 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7656 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7657 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7658 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7659 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7660 ssdcableangle,2);
7661 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7662 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7663 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7664 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7665 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7666 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3]+fgkSSDCablesLay5RightSideHeight;
7667 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7668 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7669 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7670 ssdcableslay5pcon[1]->SetLineColor(9);
7671 ////////////////////////////////////
7672 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7673 ssdcableangle,2);
7674 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7675 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7676 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7677 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7678 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7679 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7680 * TanD(fgkSSDPConeAngle)
7681 + 0.5*fgkSSDCentralSupportLength
7682 + fgkSSDCentralAL3SupportLength;
7683 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7684 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7685 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7686 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7687 ssdcableslay5pcon[2]->SetLineColor(9);
7688////////////////////////////////////
7689 TGeoRotation* ssdcableslay5pconrot[4];
7690 for(Int_t i=0; i<4; i++){
7691 ssdcableslay5pconrot[i] = new TGeoRotation();
7692 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7693 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7694 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
7695 }
7696 ////////////////////////////////////
7697 //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7698 //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7699 ////////////////////////////////////
7700 // Positioning Left SSD Cables Part
7701 ////////////////////////////////////
7702 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7703 - 0.5*ssdcablelay5rightsidelength
7704 - fgkEndCapSupportCenterLay5Position
7705 - fgkEndCapSupportCenterLay5ITSPosition);
7706 ssdcablesmother->AddNode(ssdcablelay5righttube,2,ssdcablesLay5RightTubeToLeftrans);
7707 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7708 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7709 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7710 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7711 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7712 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7713 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7714 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7715 }
7716 ////////////////////////////////////
7717 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7718 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7719 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7720 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7721 /////////////////////////////////////////////////////////////
7722 // Water Tubes Layer 5
7723 /////////////////////////
7724 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7725 ssdcableslay5rightsideradiusmax
7726 + fgkSSDCablesLay5RightSideWaterHeight,
7727 0.5*ssdcablelay5rightsidelength);
7728 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7729 ssdcablelay5rightubewatershape,
7730 fSSDCoolingTubeWater);
7731 ssdcablelay5rightwatertube->SetLineColor(7);
7732 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7733 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7734 ////////////////////////////////////
7735 // TGeoPCone Water Volumes Layer
7736 ///////////////////////////////////
7737 TGeoPcon* ssdcableslay5pconwatershape[3];
7738 TGeoVolume* ssdcableslay5pconwater[3];
7739 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7740 Double_t ssdcableslay5pconwaterzsection[6];
7741 Double_t ssdcableslay5pcwateronrmin[6];
7742 Double_t ssdcableslay5pconwaterrmax[6];
7743 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7744 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7745 + fgkSSDCablesLay5RightSideWaterHeight;
7746 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7747 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7748 + fgkSSDCablesLay5RightSideWaterHeight;
7749 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7750 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7751 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7752 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7753 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7754 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7755 ssdcableslay5pconwater[0]->SetLineColor(7);
7756 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7757 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7758////////////////////////////////////
7759 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7760 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7761 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7762 ssdcableangle,2);
7763 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7764 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7765 + fgkSSDCablesLay5RightSideWaterHeight;
7766 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7767 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7768 + fgkSSDCablesLay5RightSideWaterHeight;
7769 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7770 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7771 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7772 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7773 ssdcableslay5pconwater[1]->SetLineColor(7);
7774////////////////////////////////////
7775 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7776 ssdcableangle,2);
7777 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7778 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7779 + fgkSSDCablesLay5RightSideWaterHeight;
7780 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7781 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7782 + fgkSSDCablesLay5RightSideWaterHeight;
7783 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7784 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7785 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7786 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7787 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7788 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7789 ssdcableslay5pconwater[2]->SetLineColor(7);
7790////////////////////////////////////
7791 TGeoRotation* ssdcableslay5pconwaterot[4];
7792 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7793 for(Int_t i=0; i<4; i++){
7794 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7795 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7796 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7797 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7798 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7799 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7800 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7801 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7802 }
7803 /////////////////////////
7804 // SSD Layer 6 Cables
7805 /////////////////////////
7806 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+fgkSSDCablesLay6TubeRadiusMin;
7807 Double_t ssdcablelay6rightsidelength = 2.*ssdcablelay5rightsidelength;
7808 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+fgkSSDCablesLay6RightSideHeight;
7809 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7810 ssdcableslay6rightsideradiusmax,
7811 0.5*ssdcablelay6rightsidelength);
7812 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7813 ssdcablelay6rightubeshape,
7814 fSSDCopper);
7815 ssdcablelay6righttube->SetLineColor(9);
7816 TGeoTranslation* ssdcablelay6rightrans =
7817 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7818 + fgkEndCapSupportCenterLay6Position
7819 + 0.5*ssdcablelay6rightsidelength);
7820 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7821 - 0.5*ssdcablelay6rightsidelength
7822 - fgkEndCapSupportCenterLay6Position
7823 - fgkEndCapSupportCenterLay6ITSPosition);
7824 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7825 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7826 ////////////////////////////////////
7827 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7828 ////////////////////////////////////
7829 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7830 ssdcableangle,2);
7831 TGeoVolume* ssdcableslay6pcon;
7832 Double_t ssdcableslay6pconrmin[2];
7833 Double_t ssdcableslay6pconrmax[2];
7834 Double_t ssdcableslay6pconzsection[2];
7835 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7836 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7837 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7838 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7839 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7840 + fgkEndCapSupportCenterLay6Position
7841 + ssdcablelay6rightsidelength;
7842 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7843 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7844 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7845 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7846 ssdcableslay6pconshape,fSSDCopper);
7847 ssdcableslay6pcon->SetLineColor(9);
7848 for(Int_t i=0; i<4; i++){
7849 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7850 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7851 }
7852 ////////////////////////////////////
7853 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7854 /////////////////////////
7855 // Water Tubes Layer 6
7856 /////////////////////////
7857 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7858 ssdcableslay6rightsideradiusmax
7859 + fgkSSDCablesLay5RightSideWaterHeight,
7860 0.5*ssdcablelay6rightsidelength);
7861 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7862 ssdcablelay6righwatertubeshape,
7863 fSSDCoolingTubeWater);
7864 ssdcablelay6rightwatertube->SetLineColor(7);
7865 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7866 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7867 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7868 ssdcableangle,2);
7869 TGeoVolume* ssdcableslay6waterpcon;
7870 Double_t ssdcableslay6waterpconrmin[2];
7871 Double_t ssdcableslay6waterpconrmax[2];
7872 Double_t ssdcableslay6waterpconzsection[2];
7873 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7874 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7875 + fgkSSDCablesLay5RightSideWaterHeight;
7876 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7877 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7878 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7879 + fgkEndCapSupportCenterLay6Position
7880 + ssdcablelay6rightsidelength;
7881 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7882 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7883 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7884 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7885 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7886 ssdcableslay6waterpcon->SetLineColor(7);
7887 TGeoRotation* ssdcableslay6pconwaterot[4];
7888 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7889 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7890 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7891 for(Int_t i=0; i<4; i++){
7892 ssdcableslay6pconwaterot[i] = new TGeoRotation();
7893 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7894 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7895 * (*ssdcableslay6pconwaterot[i]));
7896 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7897 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7898 }
7899 ////////////////////////////////////////
7900 // From ITS Ring to Patch Panel3-RB26
7901 ////////////////////////////////////////
7902 Double_t ssdcablepatchpanel3BB26radiusmin[2];
7903 Double_t ssdcablepatchpanel3BB26radiusmax[2];
7904 Double_t ssdcablepatchpanel3RB26zsection[2];
cd2243fb 7905 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8;
47f8de53 7906 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
7907 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7908 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7909 ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
7910 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
7911 + 0.*fgkSSDCablesLay5RightSideHeight
cd2243fb 7912 + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7913 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
7914 + fgkSSDCentralAL3SupportLength
7915 + fgkSSDPConeZLength[0];
7916 ssdcablepatchpanel3RB26zsection[1] = fgkSSDPatchPanel2RB26ITSDistance;
7917 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
7918 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7919 - 0.5*ssdcableangle,ssdcableangle,2);
7920 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7921 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7922 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7923 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7924 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
7925 TGeoRotation* ssdcablepatchpanel3B26rot[3];
7926 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
67446e8a 7927 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
47f8de53 7928 ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
67446e8a 7929 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7930 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
47f8de53 7931 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0]
67446e8a 7932 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
47f8de53 7933 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
7934 ////////////////////////////////////
7935 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7936 ////////////////////////////////////////
7937 // ITS Ring Cables RB26 Part
7938 ////////////////////////////////////////
7939 Double_t ssdcableitsring3BB26pconzsection[2];
7940 Double_t ssdcableitsring3BB26pconrmin[2];
7941 Double_t ssdcableitsring3BB26pconrmax[2];
7942 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7943 + fgkSSDCentralAL3SupportLength
7944 + (4.0/5.0)*fgkSSDPConeZLength[0];
7945 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
cd2243fb 7946 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
47f8de53 7947 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
7948 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7949 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7950 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7951 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7952 TGeoPcon* ssdcableitsring3BB26pconshape[4];
7953 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7954 - 0.5*ssdcableangle,ssdcableangle
7955 + (fgkSSDCablesPatchPanel2RB26Angle[0]
7956 - fgkSSDCableAngle),2);
7957 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7958 - 0.5*ssdcableangle,ssdcableangle
7959 + 3.0*fgkSSDCableAngle
7960 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7961 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-fgkSSDCablesPatchPanel2RB26Angle[0]
7962 - 0.5*ssdcableangle,ssdcableangle
7963 - fgkSSDCableAngle
7964 + fgkSSDCablesPatchPanel2RB26Angle[0],2);
7965 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7966 - 0.5*ssdcableangle,ssdcableangle
7967 + 3.0*fgkSSDCableAngle
7968 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7969 for(Int_t i=0;i<4;i++)
7970 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7971 ssdcableitsring3BB26pconrmin[j],
7972 ssdcableitsring3BB26pconrmax[j]);
7973 TGeoVolume* ssdcableitsring3BB26pcon[4];
7974 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7975 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7976 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7977 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7978 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7979 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7980 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7981 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7982 for(Int_t i=0;i<4;i++){
7983 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
5ef8864c 7984 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
47f8de53 7985}
7986 ////////////////////////////////////
7987 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7988 // + ssdcableitsring3BB26pconshape[1]->Capacity()
7989 // + ssdcableitsring3BB26pconshape[2]->Capacity()
7990 // + ssdcableitsring3BB26pconshape[3]->Capacity();
7991 ////////////////////////////////////////
7992 // From ITS Ring to Patch Panel2-RB24
7993 ////////////////////////////////////////
7994 Double_t ssdcablepatchpanel3BB24radiusmin[2];
7995 Double_t ssdcablepatchpanel3BB24radiusmax[2];
7996 Double_t ssdcablepatchpanel3RB24zsection[2];
7997 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7998 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
7999 ssdcablepatchpanel3BB24radiusmin[1] = fgkSSDPatchPanel2RB24Radius;
8000 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
8001 + 0.*fgkSSDCablesLay5RightSideHeight
8002 + 0.*fgkSSDCablesLay6RightSideHeight
cd2243fb 8003 + 0.5*fgkSSDPatchPanelHeight;
47f8de53 8004 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
8005 - fgkSSDCentralAL3SupportLength
8006 - fgkSSDPConeZLength[0];
8007 ssdcablepatchpanel3RB24zsection[1] = -fgkSSDPatchPanel2RB24ITSDistance;
8008 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
8009 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
8010 - 0.5*ssdcableangle,ssdcableangle,2);
8011 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
8012 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
8013 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
8014 ssdcablepatchpanel3RB24pconshape,
8015 fSSDCopper);
8016 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
8017 TGeoRotation* ssdcablepatchpanel3B24rot[3];
8018 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
67446e8a 8019 ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
47f8de53 8020 ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0]
8021 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
67446e8a 8022 ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
47f8de53 8023 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0]
8024 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
8025 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
8026 ////////////////////////////////////
8027 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
8028 ////////////////////////////////////////
8029 // ITS Ring Cables RB24 Part
8030 ////////////////////////////////////////
8031 Double_t ssdcableitsring3BB24pconzsection[2];
8032 Double_t ssdcableitsring3BB24pconrmin[2];
8033 Double_t ssdcableitsring3BB24pconrmax[2];
8034 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
8035 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
cd2243fb 8036 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
47f8de53 8037 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
8038 + fgkSSDCablesLay5RightSideHeight
cd2243fb 8039 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 8040 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
8041 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
8042 TGeoPcon* ssdcableitsring3BB24pconshape[4];
8043 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
8044 + (90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
8045 - fgkSSDCableAngle),2);
8046 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+fgkSSDCableAngle-0.5*ssdcableangle,
8047 ssdcableangle-fgkSSDCableAngle
8048 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
8049 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
8050 - fgkSSDCableAngle
8051 + 90.0-fgkSSDCablesPatchPanel2RB24Angle[1],2);
5ef8864c 8052 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+fgkSSDCableAngle-0.5*ssdcableangle,
47f8de53 8053 ssdcableangle-fgkSSDCableAngle
8054 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
8055 for(Int_t i=0;i<4;i++)
8056 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
8057 ssdcableitsring3BB24pconrmin[j],
8058 ssdcableitsring3BB24pconrmax[j]);
8059 TGeoVolume* ssdcableitsring3BB24pcon[4];
8060 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
8061 ssdcableitsring3BB24pconshape[0],fSSDCopper);
8062 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
8063 ssdcableitsring3BB24pconshape[1],fSSDCopper);
8064 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
8065 ssdcableitsring3BB24pconshape[2],fSSDCopper);
8066 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
8067 ssdcableitsring3BB24pconshape[3],fSSDCopper);
8068 for(Int_t i=0;i<4;i++){
8069 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
5ef8864c 8070 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
47f8de53 8071}
8072 ////////////////////////////////////
8073 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
8074 // + ssdcableitsring3BB24pconshape[1]->Capacity()
8075 // + ssdcableitsring3BB24pconshape[2]->Capacity()
8076 // + ssdcableitsring3BB24pconshape[3]->Capacity();
8077 ////////////////////////////////////
8078 // Volumes for Material Budget
8079 ////////////////////////////////////
8080 TGeoTube* ssdcablelay6materialbudgetubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax
8081 + fgkSSDCablesLay5RightSideWaterHeight,
8082 ssdcableslay6rightsideradiusmax
8083 + fgkSSDCablesLay5RightSideWaterHeight
8084 + fgkSSDCableMaterialBudgetHeight,0.5*ssdcablelay6rightsidelength);
8085 TGeoVolume* ssdcablelay6materialbudgetube = new TGeoVolume("SSDCableLay6MaterialBudgetTube",
8086 ssdcablelay6materialbudgetubeshape,
8087 fSSDCopper);
8088 ssdcablelay6materialbudgetube->SetLineColor(9);
8089 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,1,ssdcablelay6rightrans);
8090 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,2,ssdcablesLay6RightTubeToLeftrans);
8091
8092 TGeoPcon* ssdcablelay6materialbudgetpconshape =
8093 new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
8094 TGeoVolume* ssdcablelay6materialbudgetpcon;
8095 Double_t ssdcablelay6materialbudgetpconrmin[2];
8096 Double_t ssdcablelay6materialbudgetpconrmax[2];
8097 Double_t ssdcablelay6materialbudgetpconzsection[2];
8098 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
8099 + fgkSSDCablesLay5RightSideWaterHeight;
8100 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
8101 + fgkSSDCableMaterialBudgetHeight;
8102 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
8103 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
8104 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
8105 + fgkEndCapSupportCenterLay6Position
8106 + ssdcablelay6rightsidelength;
8107 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
8108 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
8109 ssdcablelay6materialbudgetpconzsection[i],
8110 ssdcablelay6materialbudgetpconrmin[i],
8111 ssdcablelay6materialbudgetpconrmax[i]);
8112 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
8113 ssdcablelay6materialbudgetpconshape,fSSDCopper);
8114 ssdcablelay6materialbudgetpcon->SetLineColor(9);
8115 for(Int_t i=0; i<4; i++){
8116 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
8117 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
8118 }
8119////////////////////////////////////
8120 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
8121 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
8122 Double_t ssdcablesvolume = 0.0;
8123 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
8124 std::cout << ssdcablesvolume << std::endl;*/
8125 return ssdcablesmother;
8126 }
8127 ////////////////////////////////////////////////////////////////////////////////
d7599219 8128TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
b671cde1 8129 Double_t height, const char* shapename, Int_t isign) const{
44285dfa 8130 /////////////////////////////////////////////////////////////
8131 // Method generating an Arb shape
8132 /////////////////////////////////////////////////////////////
8133 const Int_t kvertexnumber = 8;
8134 const Int_t ktransvectnumber = 2;
b671cde1 8135 TVector3 vertex[kvertexnumber];
8136 TVector3 transvector[2];
8137 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
44285dfa 8138 /////////////////////////////////////////////////////////////
d7599219 8139 //Setting the vertices for TGeoArb8
44285dfa 8140 /////////////////////////////////////////////////////////////
b671cde1 8141 vertex[0] = *vertexpos[0];
8142 vertex[1] = *vertexpos[1];
8143 vertex[2] = vertex[1];
8144 vertex[3] = vertex[0];
8145 vertex[4] = *vertexpos[2];
8146 vertex[5] = *vertexpos[3];
8147 vertex[6] = vertex[5];
8148 vertex[7] = vertex[4];
8149
8150 // NB: order of points is clockwise
8151 if (isign < 0) {
8152 vertex[2] -= transvector[0];
8153 vertex[3] -= transvector[0];
8154 vertex[6] -= transvector[1];
8155 vertex[7] -= transvector[1];
8156 }
8157 else {
8158 vertex[0] += transvector[0];
8159 vertex[1] += transvector[0];
8160 vertex[4] += transvector[1];
8161 vertex[5] += transvector[1];
8162 }
8163
44285dfa 8164 /////////////////////////////////////////////////////////////
8165 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
b671cde1 8166 for(Int_t i = 0; i<kvertexnumber;i++) {
8167 arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
8168 }
8169
44285dfa 8170 return arbshape;
d7599219 8171}
bf210566 8172///////////////////////////////////////////////////////////////////////////////
8173TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8174 Double_t rmax, Int_t nedges, Double_t height){
8175 /////////////////////////////////////////////////////////////
8176 // Method generating Arc shape
8177 /////////////////////////////////////////////////////////////
8178 const Int_t kvertexnumber = 2*nedges+2;
8179 TGeoXtru* arcshape = new TGeoXtru(2);
8180 TVector3** vertexposition[2];
8181 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8182 Double_t angle = 0.;
8183 for(Int_t i=0; i<nedges+1; i++){
8184 angle = 90.+0.5*phi-i*(phi/nedges);
8185 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
8186 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
8187 }
8188 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8189 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8190 for(Int_t i=0; i<kvertexnumber; i++){
8191 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8192 yvertexpoints[i] = vertexposition[0][i]->Y();
8193 }
8194 else if(i>=1&&i<nedges+2)
8195 {
8196 xvertexpoints[i] = vertexposition[1][i-1]->X();
8197 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8198 }
8199 else
8200 {
8201 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8202 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8203 }
8204 }
8205 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8206 arcshape->DefineSection(0,-0.5*height);
8207 arcshape->DefineSection(1,0.5*height);
44285dfa 8208 /////////////////////////////////////////////////////////////
bf210566 8209 // Deallocating memory
44285dfa 8210 /////////////////////////////////////////////////////////////
bf210566 8211 for(Int_t i=0; i<2; i++){
8212 for(Int_t j=0; j<nedges+1; j++)
8213 delete vertexposition[i][j];
8214 delete [] vertexposition[i];
8215 }
8216 delete [] xvertexpoints;
8217 delete [] yvertexpoints;
8218 /////////////////////////////////////////////////////////////
8219 return arcshape;
d7599219 8220}
8221////////////////////////////////////////////////////////////////////////////////
851c0ce3 8222TGeoShape* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
9b0c60ab 8223 ///////////////////////////////////////////////////////////////////////
8224 // Method Generating the Screw Shape
8225 // radius[0]: outer radius
8226 // radius[1]: inner radius
8227 // edgesnumber[0]: outer number of edges
8228 // edgesnumber[1]: inner number of edges
8229 // section[0]: lower section position
8230 // section[1]: higher section position
8231 ///////////////////////////////////////////////////////////////////////
8232 Double_t outradius = radius[0];
8233 Double_t inradius = radius[1];
8234 Int_t outvertexnumber = edgesnumber[0];
8235 Int_t invertexnumber = edgesnumber[1];
851c0ce3 8236 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8237 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8238 for(Int_t i=0; i<outvertexnumber; i++){
9b0c60ab 8239 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8240 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8241 }
851c0ce3 8242 for(Int_t i=0; i<invertexnumber; i++){
8243 xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8244 yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
9b0c60ab 8245 }
851c0ce3 8246 TGeoXtru* screwshapeout = new TGeoXtru(2);
8247 screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8248 screwshapeout->DefineSection(0,section[0]);
8249 screwshapeout->DefineSection(1,section[1]);
8250 TGeoXtru* screwshapein = new TGeoXtru(2);
8251 screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8252 screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8253 screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8254 TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8255 TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8256
9b0c60ab 8257 delete [] xscrewvertex;
8258 delete [] yscrewvertex;
8259 return screwshape;
8260}
8261////////////////////////////////////////////////////////////////////////////////
851c0ce3 8262TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
9b0c60ab 8263 ///////////////////////////////////////////////////////////////////////
8264 // Method Generating the Hole Shape
8265 // radius of the Hole
8266 // nedges: number of edges to approximate the circle
8267 ///////////////////////////////////////////////////////////////////////
851c0ce3 8268 Double_t* xholevertex = new Double_t[nedges];
8269 Double_t* yholevertex = new Double_t[nedges];
8270 Double_t z = 0.5*(section[0]+section[1]);
8271 Double_t dz = 0.5*(section[1]-section[0]);
8272 TGeoTranslation *tr = 0;
8273 if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8274 tr = new TGeoTranslation(0.,0.,z);
8275 tr->RegisterYourself();
8276 }
8277 TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8278 for(Int_t i=0; i<nedges; i++){
8279 xholevertex[i] = radius*CosD(i*360./nedges);
8280 yholevertex[i] = radius*SinD(i*360./nedges);
9b0c60ab 8281 }
851c0ce3 8282 TGeoXtru* holeshapeout = new TGeoXtru(2);
8283 holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8284 holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8285 holeshapeout->DefineSection(1,section[1]+0.01);
8286 TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8287 TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8288
9b0c60ab 8289 delete [] xholevertex;
8290 delete [] yholevertex;
8291 return holeshape;
8292}
8293////////////////////////////////////////////////////////////////////////////////
44285dfa 8294TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
8295 /////////////////////////////////////////////////////////////
8296 // Given an axis specified by param, it gives the reflection of the point
8297 // respect to the axis
8298 /////////////////////////////////////////////////////////////
8299 TVector3* n = new TVector3(param[0],param[1],param[2]);
8300 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8301 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 8302 /////////////////////////////////////////////////////////////
8303 // Deallocating memory
8304 /////////////////////////////////////////////////////////////
8305 delete n;
8306 /////////////////////////////////////////////////////////////
44285dfa 8307 return reflectedvector;
d7599219 8308}
8309////////////////////////////////////////////////////////////////////////////////
bf210566 8310TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
d7599219 8311 Double_t dx,
8312 Double_t dy,
8313 Double_t dz) const{
44285dfa 8314 /////////////////////////////////////////////////////////////
d7599219 8315 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 8316 /////////////////////////////////////////////////////////////
bf210566 8317 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8318 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 8319 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 8320 hmatrix->SetTranslation(newvect);
8321 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8322 delete hmatrix;
8323 return matrix;
d7599219 8324}
8325////////////////////////////////////////////////////////////////////////////////
d7599219 8326TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 8327 /////////////////////////////////////////////////////////////
8328 // Method returning the Medium type
8329 /////////////////////////////////////////////////////////////
a3f8715e 8330 char ch[100];
d7599219 8331 sprintf(ch, "ITS_%s",mediumName);
8332 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8333 if (! medium)
160835d5 8334 AliError(Form("medium %s not found !\n", mediumName));
d7599219 8335 return medium;
8336}
8337////////////////////////////////////////////////////////////////////////////////
d7599219 8338void AliITSv11GeometrySSD::CreateMaterials(){
8339///////////////////////////////////
8340// This part has to be modified
8341///////////////////////////////////
8342 ///////////////////////////////////
8343 // Silicon for Sensor
8344 ///////////////////////////////////
bf210566 8345 fSSDSensorMedium = GetMedium("SI$");
d7599219 8346 ///////////////////////////////////
8347 // Silicon Mixture for Sensor
8348 ///////////////////////////////////
44285dfa 8349 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8350 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 8351 ///////////////////////////////////
8352 // Stiffener Components Materials
8353 ///////////////////////////////////
bf210566 8354 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 8355 ///////////////////////////
8356 // Stiffener Connectors
8357 ///////////////////////////
bf210566 8358 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 8359 ////////////////////////////////
8360 // Stiffener 0603-1812 Capacitor
8361 ////////////////////////////////
bf210566 8362 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8363 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
d7599219 8364 ///////////////////////////
8365 // Stiffener Hybrid Wire
8366 ///////////////////////////
bf210566 8367 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 8368 ///////////////////////////
8369 // Al for Cooling Block
8370 ///////////////////////////
bf210566 8371 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 8372 //////////////////////////////////////////////////////
8373 // Kapton and Al for Chip Cable Flex and Ladder Cables
8374 //////////////////////////////////////////////////////
bf210566 8375 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8376 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8377 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8378 fSSDAlTraceFlexMedium = GetMedium("AL$");
8379 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8380 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 8381 /////////////////////////////////////////////////////////////////
8382 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8383 //////////////////////////////////////////////////////////////////
44285dfa 8384 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 8385 /////////////////////////////////////////////////////////////////
8386 // G10 for Detector Leg, TubeHolder
8387 //////////////////////////////////////////////////////////////////
44285dfa 8388 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8389 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8390 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8391 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 8392 /////////////////////////////////////////////////////////////////
8393 // Water and Phynox for Cooling Tube
8394 //////////////////////////////////////////////////////////////////
bf210566 8395 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 8396 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 8397 /////////////////////////////////////////////////////////////////////
9b0c60ab 8398 // Material for Support Rings
8399 /////////////////////////////////////////////////////////////////////
8400 fSSDSupportRingAl = GetMedium("AL$");
47f8de53 8401 fSSDRohaCellCone = GetMedium("ROHACELL$");
9b0c60ab 8402 /////////////////////////////////////////////////////////////////////
bf210566 8403 fSSDAir = GetMedium("SDD AIR$");
47f8de53 8404 fSSDCopper = GetMedium("COPPER$");
bf210566 8405 fCreateMaterials = kTRUE;
d7599219 8406}
8407/////////////////////////////////////////////////////////////////////