]> 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
SSD geometry: added ladders supports, endcaps and endcaps support
[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySSD.cxx
CommitLineData
d7599219 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
9b0c60ab 16/* $Id$ */
d7599219 17
18//*************************************************************************
19// SSD geometry, based on ROOT geometrical modeler
20//
21// Enrico Cattaruzza ecattar@ts.infn.it
22//*************************************************************************
23#include "TMath.h"
24#include "TGeoVolume.h"
d7599219 25#include "TGeoMatrix.h"
26#include <TGeoManager.h>
d7599219 27#include "TVector3.h"
28#include "TGeoArb8.h"
29#include "TList.h"
30#include "TGeoMatrix.h"
31#include "TGeoCompositeShape.h"
32#include "TGeoTube.h"
33#include "TGeoBBox.h"
bf210566 34#include "TGeoXtru.h"
9b0c60ab 35#include "TGeoTorus.h"
36#include "TGeoPgon.h"
37#include "TRotation.h"
44285dfa 38#include "AliITSv11GeometrySSD.h"
d7599219 39/////////////////////////////////////////////////////////////////////////////////
bf210566 40// Names of the Sensitive Volumes of Layer 5 and Layer 6
41/////////////////////////////////////////////////////////////////////////////////
42const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName5 = "ITSsddSensitivL5";
43const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName6 = "ITSsddSensitivL6";
44/////////////////////////////////////////////////////////////////////////////////
d7599219 45//Parameters for SSD Geometry
46/////////////////////////////////////////////////////////////////////////////////
47// Layer5 (lengths are in mm and angles in degrees)
48/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 49const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
d7599219 50const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
51const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
9acf2ecc 52const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
53const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
54const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
d7599219 55/////////////////////////////////////////////////////////////////////////////////
56// Layer6 (lengths are in mm and angles in degrees)
57/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 58const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
d7599219 59const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
60const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
9acf2ecc 61const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
62const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
63const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
d7599219 64/////////////////////////////////////////////////////////////////////////////////
65// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
66/////////////////////////////////////////////////////////////////////////////////
67const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
9acf2ecc 68const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
69const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
70const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
71const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
bf210566 72const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
73const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
9acf2ecc 74const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
d7599219 75/////////////////////////////////////////////////////////////////////////////////
76// Stiffener (lengths are in mm and angles in degrees)
77/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 78const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
79const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
bf210566 80//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 3.315;
9acf2ecc 81const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm;
82const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
bf210566 83const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
9acf2ecc 84const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
85const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
86const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
87const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
bf210566 88const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 0.700*fgkmm; // multiplied by 0.5
9acf2ecc 89const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
90const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
bf210566 91const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] =
92 {44.32*fgkmm, 0.33*fgkmm};
93const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
94const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
95const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
d7599219 96const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight =
bf210566 97 0.25*fgkSSDStiffenerHeight;
98const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
99const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
d7599219 100/////////////////////////////////////////////////////////////////////////////////
101// Cooling Block (lengths are in mm and angles in degrees)
102/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 103const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
104const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
bf210566 105const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
106 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
d7599219 107const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
bf210566 108 {1.000*fgkmm, 0.120*fgkmm};
d7599219 109const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
bf210566 110 {1.900*fgkmm, 0.400*fgkmm};
d7599219 111const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
9acf2ecc 112 1.500*fgkmm;
d7599219 113const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
9acf2ecc 114 0.300*fgkmm;
d7599219 115/////////////////////////////////////////////////////////////////////////////////
116// SSD Sensor (lengths are in mm and angles in degrees)
117/////////////////////////////////////////////////////////////////////////////////
118const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
bf210566 119 "SSDSensorSensitiveVol";
9acf2ecc 120const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
121const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
122const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
d7599219 123const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
9acf2ecc 124 fgkSSDSensorLength-39.1*fgkmm;
bf210566 125const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
126const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
d7599219 127/////////////////////////////////////////////////////////////////////////////////
128// Flex (lengths are in mm and angles in degrees)
129/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 130const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
d7599219 131const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
bf210566 132 {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
133 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
134 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
135 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
136 - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
d7599219 137const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
bf210566 138 { 9.340*fgkmm, 5.380*fgkmm};
d7599219 139const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
bf210566 140 { 0.030*fgkmm, 0.020*fgkmm};
d7599219 141const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
9acf2ecc 142const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
143const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
d7599219 144const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
bf210566 145 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
d7599219 146const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
bf210566 147 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
d7599219 148/////////////////////////////////////////////////////////////////////////////////
149// SSD Ladder Cable (lengths are in mm and angles in degrees)
150/////////////////////////////////////////////////////////////////////////////////
bf210566 151const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
d7599219 152/////////////////////////////////////////////////////////////////////////////////
153// SSD Module (lengths are in mm and angles in degrees)
154/////////////////////////////////////////////////////////////////////////////////
155const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
bf210566 156 { 1.000*fgkmm, 3.900*fgkmm};
d7599219 157const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
9acf2ecc 158 45.600*fgkmm;
d7599219 159const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
9acf2ecc 160 5.075*fgkmm;
d7599219 161/////////////////////////////////////////////////////////////////////////////////
162// Sensor Support (lengths are in mm and angles in degrees)
163/////////////////////////////////////////////////////////////////////////////////
bf210566 164const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
165 5.800*fgkmm;
d7599219 166const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
bf210566 167 2.000*fgkmm;
d7599219 168const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
bf210566 169 { 4.620*fgkmm, 5.180*fgkmm};
170const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
171 { 0.450*fgkmm, 0.450*fgkmm};
172const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
173 = 0.5 * (fgkSSDModuleSensorSupportDistance
174 + fgkSSDSensorSideSupportThickness[0])
175 - fgkSSDSensorSideSupportLength;
d7599219 176const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
bf210566 177 5.250*fgkmm;
d7599219 178const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
bf210566 179 1.680*fgkmm;
180const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
181 = {fgkSSDSensorSideSupportHeight[0]
182 + fgkSSDSensorSideSupportThickness[0],
183 fgkSSDSensorSideSupportHeight[1]
184 + fgkSSDSensorSideSupportThickness[1]};
185const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
186 = {fgkSSDSensorSideSupportThickness[0],
187 fgkSSDSensorSideSupportThickness[1]};
d7599219 188const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
bf210566 189 19.000*fgkmm;
d7599219 190/////////////////////////////////////////////////////////////////////////////////
191// Chip Cables (lengths are in mm and angles in degrees)
192/////////////////////////////////////////////////////////////////////////////////
193const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
bf210566 194 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
d7599219 195const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
bf210566 196 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
197 - (fgkSSDSensorSideSupportHeight[1]
198 - fgkSSDSensorSideSupportHeight[0])
199 - fgkSSDCoolingBlockHoleCenter
200 - fgkSSDStiffenerHeight
201 - fgkSSDChipHeight-fgkSSDSensorHeight,
202 fgkSSDModuleCoolingBlockToSensor
203 - fgkSSDCoolingBlockHoleCenter
204 - fgkSSDStiffenerHeight
205 - fgkSSDChipHeight-fgkSSDSensorHeight};
d7599219 206const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
bf210566 207 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
d7599219 208/////////////////////////////////////////////////////////////////////////////////
209// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
210/////////////////////////////////////////////////////////////////////////////////
211const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
bf210566 212 3.820*fgkmm;
213//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
214// 3.780;
d7599219 215const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
bf210566 216 fgkSSDSensorLength-fgkSSDSensorOverlap;
d7599219 217const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
bf210566 218 { 0.86*fgkmm, 0.30*fgkmm};
d7599219 219const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
bf210566 220 { 30.00, 90.00};
d7599219 221const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
bf210566 222 1.78*fgkmm;
d7599219 223/////////////////////////////////////////////////////////////////////////////////
224//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
225/////////////////////////////////////////////////////////////////////////////////
bf210566 226const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
227 = fgkSSDModuleSensorSupportDistance
228 - 2. * fgkCarbonFiberJunctionToSensorSupport;
229const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
d7599219 230const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
bf210566 231 { 0.751*fgkmm, 0.482*fgkmm};
232const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
233 1.630*fgkmm;
234const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
235const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
236 = fgkCarbonFiberTriangleLength
237 - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
238 / TMath::Cos(fgkCarbonFiberTriangleAngle
239 * TMath::DegToRad());
240const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
241 = 0.5*(fgkCarbonFiberJunctionWidth
242 - fgkCarbonFiberSupportWidth)
243 - fgkCarbonFiberSupportTopEdgeDist[0]
244 - fgkCarbonFiberSupportWidth;
d7599219 245/////////////////////////////////////////////////////////////////////////////////
246// Carbon Fiber Lower Support Parameters (lengths are in mm)
247/////////////////////////////////////////////////////////////////////////////////
248const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
9acf2ecc 249 = 0.950*fgkmm;
d7599219 250const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
9acf2ecc 251 = 1.600*fgkmm;
d7599219 252const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
9acf2ecc 253 = 0.830*fgkmm;
d7599219 254const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
255 = 0.5*fgkCarbonFiberSupportWidth;
256const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
bf210566 257 = fgkCarbonFiberJunctionWidth
258 - 2. * (fgkCarbonFiberLowerSupportWidth
259 + fgkCarbonFiberLowerSupportVolumeSeparation);
d7599219 260const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
bf210566 261 = {fgkCarbonFiberLowerSupportWidth
262 + fgkCarbonFiberLowerSupportVolumeSeparation,
263 fgkCarbonFiberLowerSupportWidth
264 + fgkCarbonFiberLowerSupportVolumeSeparation
265 + fgkCarbonFiberLowerSupportTransverseWidth};
d7599219 266/////////////////////////////////////////////////////////////////////////////////
267// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
268/////////////////////////////////////////////////////////////////////////////////
269const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
bf210566 270 {0.5 * (fgkSSDLay5LadderLength
271 - fgkSSDLay5SensorsNumber
272 * fgkCarbonFiberJunctionWidth
273 - fgkCarbonFiberLowerSupportWidth),
274 0.5 * (fgkSSDLay5LadderLength
275 - fgkSSDLay5SensorsNumber
276 * fgkCarbonFiberJunctionWidth
277 + fgkCarbonFiberLowerSupportWidth)};
d7599219 278const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
bf210566 279 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
280 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
d7599219 281const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
bf210566 282 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
283 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
9b0c60ab 284const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
285 {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
d7599219 286/////////////////////////////////////////////////////////////////////////////////
287// Cooling Tube Support (lengths are in mm and angles in degrees)
288/////////////////////////////////////////////////////////////////////////////////
bf210566 289const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
d7599219 290const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
291 = fgkSSDCoolingBlockHoleRadius[0];
bf210566 292const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
293const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
294const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
d7599219 295const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
bf210566 296 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
297const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
298 11.70*fgkmm;
d7599219 299/////////////////////////////////////////////////////////////////////////////////
300// Cooling Tube (lengths are in mm and angles in degrees)
301/////////////////////////////////////////////////////////////////////////////////
bf210566 302const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
303const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm;
304const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
d7599219 305 fgkCarbonFiberJunctionWidth;
306const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
bf210566 307 fgkSSDModuleSensorSupportDistance
308 + fgkSSDCoolingBlockLength;
9b0c60ab 309const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
d7599219 310/////////////////////////////////////////////////////////////////////////////////
311// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
312/////////////////////////////////////////////////////////////////////////////////
313const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
bf210566 314 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
d7599219 315const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
bf210566 316 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
d7599219 317const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
bf210566 318 20.0*fgkmm;
d7599219 319const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
bf210566 320 40.0;
d7599219 321const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
322 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
323const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
bf210566 324 2.5*fgkmm;
d7599219 325const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
bf210566 326 { 56.0*fgkmm, 12.0*fgkmm};
d7599219 327const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
bf210566 328 { 5.0*fgkmm, 2.9*fgkmm};
d7599219 329const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
bf210566 330 1.0*fgkmm;
d7599219 331const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
bf210566 332 6.0*fgkmm;
d7599219 333const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth =
bf210566 334 4.0*fgkmm;
d7599219 335const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
bf210566 336 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
d7599219 337/////////////////////////////////////////////////////////////////////////////////
9b0c60ab 338// SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
339/////////////////////////////////////////////////////////////////////////////////
340const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
341const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
342const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
343const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
344const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
345/////////////////////////////////////////////////////////////////////////////////
346// SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
347/////////////////////////////////////////////////////////////////////////////////
348const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
349const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
350const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
351 - fgkSSDMountingBlockHeight[1]
352 + 0.5*fgkCoolingTubeSupportHeight
353 + fgkSSDModuleCoolingBlockToSensor
354 - fgkMountingBlockSupportDownHeight,
355 fgkSSDLay6RadiusMin
356 - fgkSSDMountingBlockHeight[1]
357 + 0.5*fgkCoolingTubeSupportHeight
358 + fgkSSDModuleCoolingBlockToSensor
359 - fgkMountingBlockSupportDownHeight};
360const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
361 - fgkSSDMountingBlockHeight[1]
362 + 0.5*fgkCoolingTubeSupportHeight
363 + fgkSSDModuleCoolingBlockToSensor
364 - fgkMountingBlockSupportRadius[0],
365 fgkSSDLay6RadiusMax
366 - fgkSSDMountingBlockHeight[1]
367 + 0.5*fgkCoolingTubeSupportHeight
368 + fgkSSDModuleCoolingBlockToSensor
369 - fgkMountingBlockSupportRadius[1]};
370const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
371const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
372const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
373/////////////////////////////////////////////////////////////////////////////////
374// SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
375/////////////////////////////////////////////////////////////////////////////////
376const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
377const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
378const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
379const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
380 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
381const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
382 {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
383const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
384 {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
385const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
386const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
387const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
388const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
389const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
390const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
391/////////////////////////////////////////////////////////////////////////////////
392// SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
393/////////////////////////////////////////////////////////////////////////////////
394const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
395const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
396const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
397/////////////////////////////////////////////////////////////////////////////////
398// SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
399/////////////////////////////////////////////////////////////////////////////////
400const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
401 {10.5*fgkmm,9.25*fgkmm};
402const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
403const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
404const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
405 {182.3,177.9,84.4,70.0,35.0};
406const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
407 {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
408const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
409/////////////////////////////////////////////////////////////////////////////////
410// SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
411/////////////////////////////////////////////////////////////////////////////////
412const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
413 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
414const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
415 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
416 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
417const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
418/////////////////////////////////////////////////////////////////////////////////
419// SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
420/////////////////////////////////////////////////////////////////////////////////
421const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
422 {62.0*fgkmm,21.87*fgkmm};
423const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
424 {47.1*fgkmm,0.35*fgkmm};
425const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
426 1.0*fgkmm;
427const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
428const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
429 {43.5*fgkmm, 0.70*fgkmm};
430const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
431 0.15*fgkmm;
432const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
433 19.0*fgkmm;
434const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
435 {4.80*fgkmm,1.1*fgkmm};
436const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
437 {3.3*fgkmm,1.10*fgkmm};
438const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
439 2.1*fgkmm;
440const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
441 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
442const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
443 {1.9*fgkmm,0.15*fgkmm};
444const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
445 19*fgkmm;
446const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
447 1.0*fgkmm;
448const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
449 3.6*fgkmm;
450const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
451 61.0*fgkmm;
452const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
453 5.97*fgkmm;
454const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
455const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
456 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
457 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
458const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
459 {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
460const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
461 1.0*fgkmm;
462const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
463 = 0.15*fgkmm;
464const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
465 20.0*fgkmm;
466const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
467const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
468const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
469const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
470const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
471/////////////////////////////////////////////////////////////////////////////////
472// SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
473/////////////////////////////////////////////////////////////////////////////////
474const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
475const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
476const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {365.0*fgkmm,430.0*fgkmm};
477const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
478const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
479const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
480const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
481const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
482const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
483/////////////////////////////////////////////////////////////////////////////////
44285dfa 484ClassImp(AliITSv11GeometrySSD)
485/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 486AliITSv11GeometrySSD::AliITSv11GeometrySSD():
487 AliITSv11Geometry(),
44285dfa 488 fSSDChipMedium(),
489 fSSDChipGlueMedium(),
490 fSSDStiffenerMedium(),
491 fSSDStiffenerConnectorMedium(),
492 fSSDStiffener0603CapacitorMedium(),
493 fSSDStiffener1812CapacitorMedium(),
494 fSSDStiffenerHybridWireMedium(),
495 fSSDKaptonFlexMedium(),
496 fSSDAlTraceFlexMedium(),
497 fSSDAlTraceLadderCableMedium(),
498 fSSDKaptonLadderCableMedium(),
499 fSSDKaptonChipCableMedium(),
500 fSSDAlTraceChipCableMedium(),
501 fSSDAlCoolBlockMedium(),
502 fSSDSensorMedium(),
503 fSSDSensorSupportMedium(),
504 fSSDCarbonFiberMedium(),
505 fSSDTubeHolderMedium(),
506 fSSDCoolingTubeWater(),
507 fSSDCoolingTubePhynox(),
9b0c60ab 508 fSSDSupportRingAl(),
44285dfa 509 fSSDMountingBlockMedium(),
bf210566 510 fSSDAir(),
511 fCreateMaterials(kFALSE),
512 fTransformationMatrices(kFALSE),
513 fBasicObjects(kFALSE),
514 fcarbonfiberjunction(),
515 fcoolingtubesupport(),
516 fhybridmatrix(),
517 fssdcoolingblocksystem(),
518 fcoolingblocksystematrix(),
519 fssdstiffenerflex(),
520 fssdendflex(),
9b0c60ab 521 fendladdercoolingtubesupportmatrix(),
bf210566 522 fendladdermountingblock(),
9b0c60ab 523 fendladdermountingblockclip(),
bf210566 524 fSSDSensor5(),
525 fSSDSensor6(),
526 fSSDLayer5(),
527 fSSDLayer6(),
528 fMotherVol(),
9b0c60ab 529 fLay5LadderSupportRing(),
530 fLay6LadderSupportRing(),
44285dfa 531 fColorCarbonFiber(4),
532 fColorRyton(5),
bf210566 533 fColorPhynox(14),
44285dfa 534 fColorSilicon(3),
bf210566 535 fColorAl(38),
44285dfa 536 fColorKapton(6),
537 fColorPolyhamide(5),
538 fColorStiffener(9),
bf210566 539 fColorEpoxy(30),
540 fColorWater(7),
541 fColorG10(41)
44285dfa 542{
543 ////////////////////////
544 // Standard constructor
545 ////////////////////////
44285dfa 546}
547/////////////////////////////////////////////////////////////////////////////////
548AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
9acf2ecc 549 AliITSv11Geometry(s.GetDebug()),
44285dfa 550 fSSDChipMedium(s.fSSDChipMedium),
551 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
552 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
553 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
554 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
555 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
556 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
557 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
558 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
559 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
560 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
561 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
562 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
563 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
564 fSSDSensorMedium(s.fSSDSensorMedium),
565 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
566 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
567 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
568 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
569 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
9b0c60ab 570 fSSDSupportRingAl(s.fSSDSupportRingAl),
44285dfa 571 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
bf210566 572 fSSDAir(s.fSSDAir),
573 fCreateMaterials(s.fCreateMaterials),
574 fTransformationMatrices(s.fTransformationMatrices),
575 fBasicObjects(s.fBasicObjects),
576 fcarbonfiberjunction(s.fcarbonfiberjunction),
577 fcoolingtubesupport(s.fcoolingtubesupport),
578 fhybridmatrix(s.fhybridmatrix),
579 fssdcoolingblocksystem(s.fssdcoolingblocksystem),
580 fcoolingblocksystematrix(s.fcoolingblocksystematrix),
581 fssdstiffenerflex(s.fssdstiffenerflex),
582 fssdendflex(s.fssdendflex),
9b0c60ab 583 fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
bf210566 584 fendladdermountingblock(s.fendladdermountingblock),
9b0c60ab 585 fendladdermountingblockclip(s.fendladdermountingblockclip),
bf210566 586 fSSDSensor5(s.fSSDSensor5),
587 fSSDSensor6(s.fSSDSensor6),
588 fSSDLayer5(s.fSSDLayer5),
589 fSSDLayer6(s.fSSDLayer6),
44285dfa 590 fMotherVol(s.fMotherVol),
9b0c60ab 591 fLay5LadderSupportRing(s.fLay5LadderSupportRing),
592 fLay6LadderSupportRing(s.fLay6LadderSupportRing),
44285dfa 593 fColorCarbonFiber(s.fColorCarbonFiber),
594 fColorRyton(s.fColorRyton),
595 fColorPhynox(s.fColorPhynox),
596 fColorSilicon(s.fColorSilicon),
597 fColorAl(s.fColorAl),
598 fColorKapton(s.fColorKapton),
599 fColorPolyhamide(s.fColorPolyhamide),
600 fColorStiffener(s.fColorStiffener),
bf210566 601 fColorEpoxy(s.fColorEpoxy),
602 fColorWater(s.fColorWater),
603 fColorG10(s.fColorG10)
44285dfa 604{
605 ////////////////////////
606 // Copy Constructor
607 ////////////////////////
d7599219 608}
609/////////////////////////////////////////////////////////////////////////////////
44285dfa 610AliITSv11GeometrySSD& AliITSv11GeometrySSD::
611operator=(const AliITSv11GeometrySSD &s){
612 ////////////////////////
613 // Assignment operator
614 ////////////////////////
615 this->~AliITSv11GeometrySSD();
616 new(this) AliITSv11GeometrySSD(s);
617 return *this;
618/*
619 if(&s == this) return *this;
620 fMotherVol = s.fMotherVol;
621 return *this;
622 */
623}
bf210566 624///////////////////////////////////////////////////////////////////////////////
625void AliITSv11GeometrySSD::CreateTransformationMatrices(){
626 ///////////////////////////////////////////////////////////////////////
627 // Method generating the trasformation matrix for the whole SSD Geometry
628 ///////////////////////////////////////////////////////////////////////
629 // Setting some variables for Carbon Fiber Supportmatrix creation
630 //////////////////////////////////////////////////////////////////////
631 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
632 * CosD(fgkCarbonFiberJunctionAngle[0]);
633 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
634 + fgkCarbonFiberSupportTopEdgeDist[0]
635 + fgkCarbonFiberSupportWidth);
636 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
637 * TanD(fgkCarbonFiberJunctionAngle[0]);
638 TGeoRotation* carbonfiberot[3];
639 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
640 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
641 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
642 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
643 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
644 * CosD(fgkCarbonFiberTriangleAngle),0.,
645 - fgkCarbonFiberTriangleLength
646 * SinD(fgkCarbonFiberTriangleAngle)};
647 ///////////////////////////////////////////
648 //Setting Local Translations and Rotations:
649 ///////////////////////////////////////////
650 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
651 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
652 0.5*carbonfibersupportheight,NULL);
653 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
654 2.*symmetryplaneposition+transvector[1],
655 transvector[2], carbonfiberot[2]);
656 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
657 /////////////////////////////////////////////////////////////
658 // Carbon Fiber Support Transformations
659 /////////////////////////////////////////////////////////////
660 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
661 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
662 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
663 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
664 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
665 }
666 /////////////////////////////////////////////////////////////
667 // Carbon Fiber Junction Transformation
668 /////////////////////////////////////////////////////////////
669 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
670 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
671 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
672 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
673 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
674 localcarbonfiberjunctionmatrix[i] =
675 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
676 localcarbonfiberjunctionrot[i] =
677 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
678 localcarbonfiberjunctiontrans[i] =
679 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 680 }
bf210566 681 ///////////////////////
682 // Setting Translations
683 ///////////////////////
684 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
685 localcarbonfiberjunctiontrans[1][0] =
686 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
687 localcarbonfiberjunctiontrans[2][0] =
688 new TGeoTranslation(fgkCarbonFiberTriangleLength
689 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
690 fgkCarbonFiberTriangleLength
691 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
692 localcarbonfiberjunctiontrans[0][1] =
693 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
694 localcarbonfiberjunctiontrans[1][1] =
695 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
696 localcarbonfiberjunctiontrans[2][1] =
697 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
698 ////////////////////
699 // Setting Rotations
700 ////////////////////
701 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
702 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
703 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
704 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
705 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
706 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
707 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
708 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
709 ////////////////////////////////////////
710 // Setting Carbon Fiber Junction matrix
711 ////////////////////////////////////////
712 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
713 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
714 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
715 localcarbonfiberjunctionmatrix[i][j] =
716 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
717 *localcarbonfiberjunctionrot[i][j]);
718 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
719 }
d7599219 720 }
bf210566 721 /////////////////////////////////////////////////////////////
722 // Carbon Fiber Lower Support Transformations
723 /////////////////////////////////////////////////////////////
724 TGeoTranslation* localcarbonfiberlowersupportrans[2];
725 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
726 fgkCarbonFiberLowerSupportVolumePosition[1]
727 + fgkCarbonFiberLowerSupportVolumePosition[0],
728 0.0);
729 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
730 fgkCarbonFiberJunctionWidth
731 - fgkCarbonFiberLowerSupportWidth
732 - fgkCarbonFiberLowerSupportVolumePosition[0]
733 - fgkCarbonFiberLowerSupportVolumePosition[1],
734 - 0.5*fgkCarbonFiberLowerSupportHeight);
735 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
736 fcarbonfiberlowersupportrans[0] =
737 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
738 fcarbonfiberlowersupportrans[1] =
739 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
740 /////////////////////////////////////////////////////////////
741 // SSD Sensor Support Transformations
742 /////////////////////////////////////////////////////////////
743 const Int_t kssdsensorsupportmatrixnumber = 3;
744 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
745 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
746 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
747 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
748 localssdsensorsupportmatrix[i] =
749 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
750 localssdsensorsupportrot[i] =
751 new TGeoRotation*[kssdsensorsupportmatrixnumber];
752 localssdsensorsupportrans[i] =
753 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 754 }
bf210566 755 ///////////////////////
756 // Setting Translations
757 ///////////////////////
758 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
759 0.5*fgkSSDSensorSideSupportWidth,
760 0.0);
761 localssdsensorsupportrans[1][0] =
762 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
763 localssdsensorsupportrans[2][0] =
764 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
765 localssdsensorsupportrans[0][1] =
766 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
767 0.5*fgkSSDSensorSideSupportThickness[0],
768 0.0);
769 localssdsensorsupportrans[1][1] =
770 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
771 - 0.5*fgkSSDSensorSideSupportThickness[0]
772 - fgkSSDModuleSensorSupportDistance,
773 0.0);
774 localssdsensorsupportrans[2][1] =
775 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
776 - fgkSSDSensorCenterSupportPosition,
777 0.5*fgkSSDSensorCenterSupportWidth
778 - 0.5*fgkSSDModuleSensorSupportDistance,
779 fgkSSDSensorCenterSupportThickness[0]);
780 localssdsensorsupportrans[0][2] =
781 new TGeoTranslation(fgkCarbonFiberTriangleLength
782 + fgkCarbonFiberJunctionToSensorSupport,
783 fgkCarbonFiberJunctionWidth
784 - 0.5*(fgkCarbonFiberLowerSupportWidth
785 + fgkSSDSensorCenterSupportLength
786 - fgkSSDSensorCenterSupportThickness[0])
787 - fgkSSDSensorCenterSupportPosition,
788 0.0);
789 localssdsensorsupportrans[1][2] =
790 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
791 localssdsensorsupportrans[2][2] =
792 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
793 ////////////////////
794 // Setting Rotations
795 ////////////////////
796 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
797 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
798 localssdsensorsupportrot[i][j] = new TGeoRotation();
799 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
800 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
801 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 802 }
bf210566 803 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
804 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
805 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
806 ////////////////////////////////////////
807 // SSD Sensor Support matrix
808 ////////////////////////////////////////
809 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
810 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
811 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
812 localssdsensorsupportmatrix[i][j] =
813 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
814 *localssdsensorsupportrot[i][j]);
815 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
816 }
d7599219 817 }
44285dfa 818 /////////////////////////////////////////////////////////////
bf210566 819 // SSD Cooling Tube Support Transformations
44285dfa 820 /////////////////////////////////////////////////////////////
bf210566 821 const Int_t kcoolingtubesupportmatrixnumber = 2;
822 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
823 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
824 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 825 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 826 /fgkCoolingTubeSupportRmax);
bf210566 827 localcoolingtubesupportrans[0] =
828 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 829 + 2.*(fgkCoolingTubeSupportLength
44285dfa 830 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 831 + fgkCarbonFiberTriangleLength
bf210566 832 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
833 localcoolingtubesupportrans[1] =
834 new TGeoTranslation(fgkCarbonFiberJunctionLength
835 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
836 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
837 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
838 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
839 - 0.5*(fgkCarbonFiberLowerSupportWidth
840 + fgkSSDSensorCenterSupportLength
841 - fgkSSDSensorCenterSupportThickness[0])
842 + 0.5*fgkSSDSensorLength,
843 - 0.5*fgkCoolingTubeSupportHeight);
844 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
845 localcoolingtubesupportrot[i] = new TGeoRotation();
846 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
847 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
848 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
849 localcoolingtubesupportmatrix[i] =
850 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
851 *localcoolingtubesupportrot[i]);
852 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
853 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
854 (*localcoolingtubesupportmatrix[0]));
855 /////////////////////////////////////////////////////////////
9b0c60ab 856 // End Ladder SSD Cooling Tube Support Transformations
857 /////////////////////////////////////////////////////////////
858 TGeoTranslation** localendladdercooltubetrans[2];
859 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
860 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
861 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
862 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
863 - (fgkCoolingTubeSupportLength
864 - fgkCoolingTubeSupportRmax),
865 fgkEndLadderMountingBlockPosition[0]
866 - fgkendladdercoolingsupportdistance[0]
867 + 0.5*fgkCoolingTubeSupportWidth,
868 - 0.5*fgkCoolingTubeSupportHeight);
869 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
870 - (fgkCoolingTubeSupportLength
871 - fgkCoolingTubeSupportRmax),
872 fgkEndLadderMountingBlockPosition[0]
873 + fgkendladdercoolingsupportdistance[1]
874 + 0.5*fgkCoolingTubeSupportWidth,
875 - 0.5*fgkCoolingTubeSupportHeight);
876 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
877 - fgkCoolingTubeSupportRmax)
878 + fgkCarbonFiberTriangleLength
879 - 2.0*fgkCarbonFiberJunctionLength,
880 0.0,
881 0.0);
882 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
883 fgkendladdercoolingsupportdistance[0]
884 + fgkendladdercoolingsupportdistance[1],
885 0.0);
886 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
887 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
888 + fgkCarbonFiberJunctionLength
889 - fgkCoolingTubeSupportLength,
890 fgkEndLadderCarbonFiberLowerJunctionLength[1]
891 - 0.5*fgkCoolingTubeSupportWidth
892 -fgkendladdercoolingsupportdistance[2],
893 - 0.5*fgkCoolingTubeSupportHeight);
894 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
895 + fgkCoolingTubeSupportLength
896 - fgkCoolingTubeSupportRmax
897 - fgkCarbonFiberJunctionLength,
898 fgkEndLadderCarbonFiberLowerJunctionLength[1]
899 - 0.5*fgkCoolingTubeSupportWidth
900 - fgkendladdercoolingsupportdistance[2],
901 - 0.5*fgkCoolingTubeSupportHeight);
902 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
903 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
904 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
905 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
906 (*localcoolingtubesupportrot[1]));
907 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
908 (*localcoolingtubesupportrot[1]));
909 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
910 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
911 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
912 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
913 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
914
915 fendladdercoolingtubesupportmatrix[1][0] =
916 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
917 *(*localcoolingtubesupportrot[1]));
918 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
919 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
920 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
921 /////////////////////////////////////////////////////////////
bf210566 922 // SSD Cooling Tube Transformations
923 /////////////////////////////////////////////////////////////
924 TGeoRotation* localcoolingtuberot = new TGeoRotation();
925 localcoolingtuberot->SetAngles(0.,90.,0.);
926 TGeoTranslation** localcoolingtubetrans[4];
927 TVector3** localcoolingtubevect[4];
928 for(Int_t i=0; i<4; i++){
929 localcoolingtubevect[i] = new TVector3*[2];
930 localcoolingtubetrans[i] = new TGeoTranslation*[2];
931 fcoolingtubematrix[i] = new TGeoHMatrix*[2];
d7599219 932 }
bf210566 933 localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
934 -fgkCarbonFiberTriangleLength),
935 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
936 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
937 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
938 - 0.5*(fgkCarbonFiberLowerSupportWidth
939 + fgkSSDSensorCenterSupportLength
940 - fgkSSDSensorCenterSupportThickness[0])+
941 0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
942 - 2.0*fgkSSDModuleStiffenerPosition[1]
943 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
944 - 0.5*fgkCoolingTubeSupportWidth,
945 - 0.5*fgkCoolingTubeSupportHeight);
946 localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
947 localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
948 - 2.0*fgkSSDModuleStiffenerPosition[1]
949 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
950 + fgkCoolingTubeSupportWidth,
951 localcoolingtubevect[0][0]->Z());
952 localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
953 + fgkCarbonFiberTriangleLength,
954 localcoolingtubevect[0][0]->Y(),
955 localcoolingtubevect[0][0]->Z());
956 localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
957 + fgkCarbonFiberTriangleLength,
958 localcoolingtubevect[0][1]->Y(),
959 localcoolingtubevect[0][1]->Z());
960 localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
961 - fgkCarbonFiberTriangleLength),
962 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
963 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
964 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
965 - 0.5*(fgkCarbonFiberLowerSupportWidth
966 + fgkSSDSensorCenterSupportLength
967 - fgkSSDSensorCenterSupportThickness[0])
968 + fgkSSDModuleStiffenerPosition[1]
969 - 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
970 - 0.5*fgkCoolingTubeSupportHeight);
971 localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
972 + fgkCarbonFiberTriangleLength,
973 localcoolingtubevect[2][0]->Y(),
974 localcoolingtubevect[2][0]->Z());
975 localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
976 - fgkCarbonFiberTriangleLength),
977 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
978 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
979 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
980 - 0.5*(fgkCarbonFiberLowerSupportWidth
981 + fgkSSDSensorCenterSupportLength
982 - fgkSSDSensorCenterSupportThickness[0])
983 + fgkSSDSensorLength
984 - 0.5*fgkSSDModuleStiffenerPosition[1],
985 - 0.5*fgkCoolingTubeSupportHeight);
986 localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
987 + fgkCarbonFiberTriangleLength,
988 localcoolingtubevect[3][0]->Y(),
989 - 0.5*fgkCoolingTubeSupportHeight);
990 for(Int_t i=0; i<4; i++)
991 for(Int_t j=0; j<2; j++){
992 localcoolingtubetrans[i][j] =
993 new TGeoTranslation(localcoolingtubevect[i][j]->X(),
994 localcoolingtubevect[i][j]->Y(),
995 localcoolingtubevect[i][j]->Z());
996 fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
997 * (*localcoolingtuberot));
998 }
999 /////////////////////////////////////////////////////////////
9b0c60ab 1000 // SSD End Ladder Cooling Tube Transformations
1001 /////////////////////////////////////////////////////////////
1002 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1003 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1004 TGeoTranslation** localendlladdercoolingtubetrans[2];
1005 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
1006 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
1007 for(Int_t i=0; i<2; i++)
1008 for(Int_t j=0; j<(i==0?6:4); j++)
1009 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1010 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1011 - fgkCoolingTubeSupportRmax)
1012 + fgkCarbonFiberJunctionLength,
1013 0.5*(fgkEndLadderMountingBlockPosition[0]
1014 - fgkendladdercoolingsupportdistance[0]),
1015 - 0.5*fgkCoolingTubeSupportHeight);
1016 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1017 - fgkCoolingTubeSupportRmax)
1018 - fgkCarbonFiberJunctionLength
1019 + fgkCarbonFiberTriangleLength,
1020 0.5*(fgkEndLadderMountingBlockPosition[0]
1021 - fgkendladdercoolingsupportdistance[0]),
1022 - 0.5*fgkCoolingTubeSupportHeight);
1023 localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1024 - fgkCoolingTubeSupportRmax)
1025 + fgkCarbonFiberJunctionLength,
1026 fgkEndLadderMountingBlockPosition[0]
1027 - fgkendladdercoolingsupportdistance[0]
1028 + 0.5*(fgkendladdercoolingsupportdistance[0]
1029 + fgkendladdercoolingsupportdistance[1]
1030 + fgkCoolingTubeSupportWidth),
1031 - 0.5*fgkCoolingTubeSupportHeight);
1032 localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
1033 - fgkCoolingTubeSupportRmax)
1034 - fgkCarbonFiberJunctionLength
1035 + fgkCarbonFiberTriangleLength,
1036 fgkEndLadderMountingBlockPosition[0]
1037 - fgkendladdercoolingsupportdistance[0]
1038 + 0.5*(fgkendladdercoolingsupportdistance[0]
1039 + fgkendladdercoolingsupportdistance[1]
1040 + fgkCoolingTubeSupportWidth),
1041 - 0.5*fgkCoolingTubeSupportHeight);
1042 localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
1043 - fgkCoolingTubeSupportRmax)
1044 + fgkCarbonFiberJunctionLength,
1045 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1046 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1047 - fgkEndLadderMountingBlockPosition[0]
1048 - fgkendladdercoolingsupportdistance[1]
1049 - fgkCoolingTubeSupportWidth),
1050 - 0.5*fgkCoolingTubeSupportHeight);
1051 localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
1052 - fgkCoolingTubeSupportRmax)
1053 - fgkCarbonFiberJunctionLength
1054 + fgkCarbonFiberTriangleLength,
1055 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1056 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1057 - fgkEndLadderMountingBlockPosition[0]
1058 - fgkendladdercoolingsupportdistance[1]
1059 - fgkCoolingTubeSupportWidth),
1060 - 0.5*fgkCoolingTubeSupportHeight);
1061 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1062 - fgkCoolingTubeSupportRmax)
1063 + fgkCarbonFiberJunctionLength,
1064 - 0.50 * (fgkMountingBlockToSensorSupport
1065 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1066 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1067 + fgkSSDSensorOverlap
1068 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1069 - fgkendladdercoolingsupportdistance[2]
1070 - fgkEndLadderMountingBlockPosition[1]
1071 - fgkCoolingTubeSupportWidth)
1072 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1073 - fgkendladdercoolingsupportdistance[2]
1074 - fgkCoolingTubeSupportWidth,
1075 - 0.5*fgkCoolingTubeSupportHeight);
1076 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1077 - fgkCoolingTubeSupportRmax)
1078 - fgkCarbonFiberJunctionLength
1079 + fgkCarbonFiberTriangleLength,
1080 - 0.50 * (fgkMountingBlockToSensorSupport
1081 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1082 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1083 + fgkSSDSensorOverlap
1084 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1085 - fgkendladdercoolingsupportdistance[2]
1086 - fgkEndLadderMountingBlockPosition[1]
1087 - fgkCoolingTubeSupportWidth)
1088 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1089 - fgkendladdercoolingsupportdistance[2]
1090 - fgkCoolingTubeSupportWidth,
1091 - 0.5*fgkCoolingTubeSupportHeight);
1092 localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1093 - fgkCoolingTubeSupportRmax)
1094 + fgkCarbonFiberJunctionLength,
1095 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1096 - 0.5*fgkendladdercoolingsupportdistance[2],
1097 - 0.5*fgkCoolingTubeSupportHeight);
1098 localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
1099 - fgkCoolingTubeSupportRmax)
1100 - fgkCarbonFiberJunctionLength
1101 + fgkCarbonFiberTriangleLength,
1102 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1103 - 0.5*fgkendladdercoolingsupportdistance[2],
1104 - 0.5*fgkCoolingTubeSupportHeight);
1105 fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
1106 fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
1107 for(Int_t i=0; i<2; i++)
1108 for(Int_t j=0; j<(i==0?6:4); j++){
1109 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1110 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1111 }
1112 /////////////////////////////////////////////////////////////
bf210566 1113 // SSD Hybrid Components Transformations
1114 /////////////////////////////////////////////////////////////
1115 const Int_t khybridmatrixnumber = 3;
1116 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1117 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1118 0.5*fgkSSDStiffenerWidth,
1119 0.5*fgkSSDStiffenerHeight);
1120 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1121 fgkSSDModuleStiffenerPosition[1],0.0);
1122
1123 localhybridtrans[2] = new TGeoTranslation(
1124 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1125 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1126 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1127 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1128 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1129 - fgkSSDSensorCenterSupportThickness[0]),
1130 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1131 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight));
1132 fhybridmatrix = new TGeoHMatrix();
1133 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1134 /////////////////////////////////////////////////////////////
1135 // SSD Cooling Block Transformations
1136 /////////////////////////////////////////////////////////////
1137 const Int_t kcoolingblockmatrixnumber = 4;
1138 TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
1139 localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
1140 - fgkCoolingTubeSupportRmin),0.0,
1141 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1142 localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
1143 - 0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
1144 0.0,fgkSSDStiffenerHeight);
1145 localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
1146 localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
1147 fcoolingblocksystematrix = new TGeoHMatrix();
1148 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
1149 fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
1150 /////////////////////////////////////////////////////////////
1151 // SSD Stiffener Flex Transformations
1152 /////////////////////////////////////////////////////////////
1153 const Int_t klocalflexmatrixnumber = 4;
1154 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1155 for(Int_t i=0; i<fgkflexnumber; i++)
1156 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1157 for(Int_t i=0; i<fgkflexnumber; i++)
1158 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1159 localflexmatrix[i][j] = new TGeoCombiTrans();
1160 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1161 - 2.*fgkSSDModuleStiffenerPosition[1]
1162 - fgkSSDStiffenerWidth;
1163 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1164 +0.5*fgkSSDStiffenerLength,
1165 0.5*fgkSSDStiffenerWidth,
1166 -0.5*fgkSSDStiffenerHeight
1167 -0.5*fgkSSDFlexHeight[0]);
1168 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1169 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1170 -0.5*fgkSSDStiffenerWidth,
1171 -0.5*fgkSSDStiffenerHeight
1172 -0.5*fgkSSDFlexHeight[0]);
1173 TGeoRotation* localflexrot = new TGeoRotation();
1174 localflexrot->SetAngles(180.,0.,0.);
1175 localflexmatrix[1][0]->SetRotation(localflexrot);
1176 for(Int_t i=0; i<fgkflexnumber; i++)
1177 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1178 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1179 for(Int_t i=0; i<fgkflexnumber; i++){
1180 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1181 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1182 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1183 }
bf210566 1184 /////////////////////////////////////////////////////////////
1185 // SSD End Flex Transformations
1186 /////////////////////////////////////////////////////////////
1187 TGeoRotation* localendflexrot = new TGeoRotation();
1188 localendflexrot->SetAngles(0.0,90.0,0.0);
1189 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1190 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1191 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1192 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1193 * TMath::DegToRad()*ssdflexradiusmax
1194 - fgkSSDFlexLength[2]-TMath::Pi()
1195 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
1196 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1197 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1198 + fgkSSDFlexLength[2];
1199 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1200 0.5*fgkSSDFlexWidth[0],
1201 2.*fgkSSDStiffenerHeight
1202 + 0.5*fgkSSDFlexHeight[0]);
1203 localendflexmatrix->SetRotation(localendflexrot);
1204 for(Int_t i=0; i<fgkflexnumber; i++)
1205 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1206 /////////////////////////////////////////////////////////////
1207 // End Ladder Carbon Fiber Junction
1208 /////////////////////////////////////////////////////////////
1209 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1210 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1211 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1212 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1213 localendladdercarbonfiberjunctionmatrix[i]
1214 = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1215 localendladdercarbonfiberjunctionrot[i]
1216 = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1217 localendladdercarbonfiberjunctiontrans[i]
1218 = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1219 fendladdercarbonfiberjunctionmatrix[i]
1220 = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
d7599219 1221 }
bf210566 1222 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1223 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1224 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1225 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1226 }
1227 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1228 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1229 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1230 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1231 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1232 0.0,0.0);
1233 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1234 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1235 * SinD(fgkCarbonFiberTriangleAngle),
1236 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1237 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1238 }
1239 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1240 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1241 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1242 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1243 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1244 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1245 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1246 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1247 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1248 localendladdercarbonfiberjunctionglobalmatrix[i] =
1249 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1250 *localendladdercarbonfiberjunctionglobalrot[i]);
1251 }
1252 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1253 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1254 localendladdercarbonfiberjunctionmatrix[i][j] =
1255 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1256 *localendladdercarbonfiberjunctionrot[i][j]);
1257 fendladdercarbonfiberjunctionmatrix[i][j] =
1258 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1259 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1260 }
1261 /////////////////////////////////////////////////////////////
1262 // End Ladder Carbon Fiber Support
1263 /////////////////////////////////////////////////////////////
1264 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1265 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1266 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1267 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1268 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1269 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1270 }
1271 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1272 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1273 fendladdercarbonfibermatrix[i][j] =
1274 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1275 *(*fcarbonfibersupportmatrix[j]));
1276 /////////////////////////////////////////////////////////////
1277 // End Ladder SSD Mounting Block
1278 /////////////////////////////////////////////////////////////
1279 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1280 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1281 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1282 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1283 + fgkSSDMountingBlockLength[1])
1284 + 0.5*fgkCarbonFiberTriangleLength,
1285 fgkEndLadderMountingBlockPosition[i],
1286 - fgkSSDMountingBlockHeight[1]
1287 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1288 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1289 endladdermountingblockrot->SetAngles(0.,90.,0.);
1290 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1291 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1292 /////////////////////////////////////////////////////////////
1293 // End Ladder SSD Mounting Block Clip Matrix
1294 /////////////////////////////////////////////////////////////
1295 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1296 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1297
1298 TGeoRotation* localendladdercliprot = new TGeoRotation();
1299 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1300 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1301 - fgkSSDMountingBlockLength[1])
1302 + fgkSSDMountingBlockLength[0],0.,0.);
1303 localendladdercliprot->SetAngles(90.,180.,-90.);
1304 TGeoCombiTrans* localendladderclipcombitrans =
1305 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1306 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1307 for(Int_t j=0; j<2; j++){
1308 fendladdermountingblockclipmatrix[i][j] =
1309 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1310 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1311 }
bf210566 1312 /////////////////////////////////////////////////////////////
1313 // End Ladder Carbon Fiber Lower Support
1314 /////////////////////////////////////////////////////////////
1315 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1316 fendladderlowersupptrans[i] =
1317 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1318 + 0.5*fgkSSDMountingBlockWidth),
1319 - 0.5*fgkCarbonFiberLowerSupportHeight);
1320 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1321 fgkCarbonFiberLowerSupportVolumePosition[1]
1322 + fgkCarbonFiberLowerSupportVolumePosition[0],
1323 0.0);
1324 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1325 /////////////////////////////////////////////////////////////
1326 // Matrix for positioning Ladder into mother volume
1327 /////////////////////////////////////////////////////////////
1328 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1329 for(Int_t i=0; i<fgkladdernumber; i++)
1330 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1331 TGeoRotation* localladdermotherrot = new TGeoRotation();
1332 localladdermotherrot->SetAngles(0.,90.,0.);
1333 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1334 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1335 for(Int_t i=0; i<fgkladdernumber; i++){
1336 localladdermothertrans[i] = new TGeoTranslation(0.,
1337 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1338 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1339 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1340 * fgkCarbonFiberJunctionWidth,0.);
1341 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1342 *localladdermotherrot);
1343 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1344 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1345 }
44285dfa 1346 /////////////////////////////////////////////////////////////
bf210566 1347 // Ladder Cables Matrices
44285dfa 1348 /////////////////////////////////////////////////////////////
44285dfa 1349 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1350 + fgkSSDFlexHeight[1];
44285dfa 1351 Double_t ssdladdercabletransx[3];
1352 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1353 * SinD(2.*fgkSSDFlexAngle)
1354 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1355 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1356 - ssdladdercabletransx[0]
bf210566 1357 / SinD(2.*fgkSSDFlexAngle))
1358 * CosD(fgkSSDFlexAngle);
44285dfa 1359 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1360 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1361 - fgkSSDFlexLength[2]-TMath::Pi()
1362 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1363 - fgkSSDLadderCableWidth)
bf210566 1364 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1365 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1366 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1367 ssdladdercabletransx[1]
bf210566 1368 * TanD(fgkSSDFlexAngle),
44285dfa 1369 ssdladdercabletransx[2]
bf210566 1370 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1371 TGeoRotation* localladdercablerot[3];
bf210566 1372 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1373 localladdercablerot[0]->SetAngles(90.,0.,0.);
1374 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1375 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1376 * (*localladdercablerot[0]));
1377 ////////////////////////////////////////////
1378 // LocalLadderCableCombiTransMatrix
1379 ////////////////////////////////////////////
1380 const Int_t klocalladdersidecablesnumber = 2;
1381 const Int_t klocalladdercombitransnumber = 5;
1382 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1383 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1384 localladdercablecombitransmatrix[i] =
1385 new TGeoCombiTrans*[klocalladdercombitransnumber];
1386 ///////////////////////////////////////////
1387 // Left Side Ladder Cables Transformations
1388 ///////////////////////////////////////////
1389 localladdercablecombitransmatrix[0][0] =
d7599219 1390 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1391 0.,0.,NULL);
bf210566 1392 localladdercablecombitransmatrix[0][1] =
1393 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1394 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1395 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1396 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1397 - 0.5*(fgkCarbonFiberLowerSupportWidth
1398 + fgkSSDSensorCenterSupportLength
1399 - fgkSSDSensorCenterSupportThickness[0]),
1400 - (fgkSSDModuleCoolingBlockToSensor
1401 + 0.5*fgkCoolingTubeSupportHeight
1402 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1403 - fgkSSDChipHeight),NULL);
44285dfa 1404 localladdercablecombitransmatrix[0][2] =
d7599219 1405 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1406 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1407 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1408 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1409 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1410 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1411 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1412 new TGeoRotation("",180.,0.,0.));
44285dfa 1413 localladdercablecombitransmatrix[0][4] =
1414 new TGeoCombiTrans(-ssdladdercabletransx[0]
1415 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1416 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1417 0.,
1418 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1419 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1420 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1421 + ssdladdercabletransz[2],localladdercablerot[2]);
1422 ///////////////////////////////////////////
1423 // Rigth Side Ladder Cables Transformations
1424 ///////////////////////////////////////////
bf210566 1425 TGeoCombiTrans* localladdercablessdmodulematrix =
1426 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1427 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1428 fgkSSDStiffenerWidth,
1429 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1430 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1431 localladdercablecombitransmatrix[1][i] =
bf210566 1432 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1433 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1434 ///////////////////////////////////////////
bf210566 1435 // Setting LadderCableHMatrix
44285dfa 1436 ///////////////////////////////////////////
bf210566 1437 Int_t beamaxistrans[2][3];
1438 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1439 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1440 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1441 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1442 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1443 beamaxistrans[1][2] = beamaxistrans[1][0];
1444 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1445 TGeoRotation* laddercablerot = new TGeoRotation();
1446 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1447 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1448 Double_t* laddercabletransvector;
1449 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1450 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1451 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1452 }
1453 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1454 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1455 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1456 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1457 localladdercablehmatrix[i][j]->MultiplyLeft(
1458 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1459 }
1460 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1461 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1462 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1463 laddercabletransvector[1]
bf210566 1464 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1465 * fgkCarbonFiberJunctionWidth,
bf210566 1466 laddercabletransvector[2]);
1467 laddercablecombitrans->SetRotation(*laddercablerot);
1468 laddercablecombitrans->SetTranslation(*laddercabletrans);
1469 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1470 }
1471 fladdercablematrix[i][2] =
1472 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1473 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1474 fladdercablematrix[i][3] =
1475 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1476 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1477 }
1478 for(Int_t i=0; i<fgkladdercablesnumber; i++)
1479 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1480 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1481 ///////////////////////////////////////////
1482 // Setting Ladder HMatrix
1483 ///////////////////////////////////////////
1484 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1485 fgkSSDLay6SensorsNumber};
1486 for(Int_t i=0; i<fgkladdernumber; i++){
1487 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1488 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1489 fladdermatrix[i][j] = new TGeoHMatrix();
1490 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1491 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1492 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1493 }
1494 }
1495 ///////////////////////////////////////////
1496 // Setting SSD Sensor Matrix
1497 ///////////////////////////////////////////
1498 TGeoCombiTrans* localssdsensorcombitrans[2];
1499 TGeoRotation* localssdsensorrot = new TGeoRotation();
1500 localssdsensorrot->SetAngles(0.,90.,0.);
1501 TGeoTranslation* localssdsensortrans[2];
1502 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1503 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1504 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1505 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1506 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1507 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1508 - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1509 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1510 - fgkSSDModuleCoolingBlockToSensor+(fgkSSDSensorSideSupportHeight[1]
1511 - fgkSSDSensorSideSupportHeight[0]));
1512 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1513 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1514 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1515 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1516 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1517 - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1518 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
1519 -fgkSSDModuleCoolingBlockToSensor);
1520 for(Int_t i=0; i<2; i++)
1521 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1522 *localssdsensorrot);
1523 for(Int_t i=0; i<fgkladdernumber; i++){
1524 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1525 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1526 switch(i){
1527 case 0: //Ladder of Layer5
1528 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1529 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1530 *localssdsensorcombitrans[1])));
1531 break;
1532 case 1: //Ladder of Layer6
1533 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1534 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1535 *localssdsensorcombitrans[0])));
1536 break;
1537 }
1538 }
1539 }
1540 //////////////////////////
1541 // Setting SSD End Ladder
1542 //////////////////////////
1543 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1544 for(Int_t i=0; i<2; i++){
1545 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1546 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1547 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1548 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1549 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1550 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1551 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1552 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1553 }
1554 /////////////////////////////////////////////////////
1555 // Setting the CombiTransformation to pass ITS center
1556 /////////////////////////////////////////////////////
1557 Double_t itscentertransz[fgklayernumber];
1558 itscentertransz[0] = fgkSSDLay5LadderLength
1559 - fgkLay5CenterITSPosition;
1560 itscentertransz[1] = fgkSSDLay6LadderLength
1561 - fgkLay6CenterITSPosition;
1562 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1563 + 0.5*fgkCoolingTubeSupportHeight;
1564 TGeoRotation* itscenterrot[3];
1565 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1566 itscenterrot[0]->SetAngles(90.,180.,-90.);
1567 itscenterrot[1]->SetAngles(0.,90.,0.);
1568 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1569 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1570 for(Int_t i=0; i<fgklayernumber; i++)
1571 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1572 itssensortransy,
1573 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1574 - itscentertransz[i],itscenterrot[2]);
1575 TGeoRotation** locallayerrot[fgklayernumber];
1576 TGeoTranslation** locallayertrans[fgklayernumber];
1577 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1578 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1579 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1580 - fgkLay5CenterITSPosition);
1581 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1582 - fgkLay6CenterITSPosition);
1583 const Int_t kssdlayladdernumber[fgklayernumber] =
1584 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1585 for(Int_t i=0; i<fgklayernumber; i++){
1586 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1587 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1588 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1589 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1590 }
1591 Double_t layerladderangleposition[fgklayernumber] =
1592 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1593 Double_t layerradius = 0.;
1594 for(Int_t i=0; i<fgklayernumber; i++){
1595 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1596 switch(i){
1597 case 0: //Ladder of Layer5
1598 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1599 break;
1600 case 1: //Ladder of Layer6
1601 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1602 break;
1603 }
1604 locallayerrot[i][j] = new TGeoRotation();
1605 locallayertrans[i][j] = new TGeoTranslation();
1606 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1607 locallayertrans[i][j]->SetTranslation(layerradius
1608 * CosD(90.0+j*layerladderangleposition[i]),
1609 layerradius
1610 * SinD(90.0+j*layerladderangleposition[i]),0.);
1611 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1612 *locallayerrot[i][j]);
1613 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1614 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1615 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1616 }
1617 }
44285dfa 1618 /////////////////////////////////////////////////////////////
bf210566 1619 // Deallocating memory
44285dfa 1620 /////////////////////////////////////////////////////////////
bf210566 1621 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1622 delete carbonfiberot[i];
1623 delete localcarbonfibersupportmatrix[i];
1624 }
1625 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1626 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1627 delete localcarbonfiberjunctionmatrix[i][j];
1628 delete localcarbonfiberjunctionrot[i][j];
1629 delete localcarbonfiberjunctiontrans[i][j];
1630 }
1631 delete [] localcarbonfiberjunctionmatrix[i];
1632 delete [] localcarbonfiberjunctionrot[i];
1633 delete [] localcarbonfiberjunctiontrans[i];
1634 }
1635 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1636 delete localcarbonfiberlowersupportrans[i];
1637 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1638 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1639 delete localssdsensorsupportmatrix[i][j];
1640 delete localssdsensorsupportrot[i][j];
1641 delete localssdsensorsupportrans[i][j];
1642 }
1643 delete [] localssdsensorsupportmatrix[i];
1644 delete [] localssdsensorsupportrot[i];
1645 delete [] localssdsensorsupportrans[i];
1646 }
1647 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1648 delete localcoolingtubesupportmatrix[i];
1649 delete localcoolingtubesupportrot[i];
1650 delete localcoolingtubesupportrans[i];
1651 }
1652 for(Int_t i=0; i<4; i++){
1653 for(Int_t j=0; j<2; j++){
1654 delete localcoolingtubevect[i][j];
1655 delete localcoolingtubetrans[i][j];
1656 }
1657 delete [] localcoolingtubevect[i];
1658 delete [] localcoolingtubetrans[i];
1659 }
9b0c60ab 1660 delete endladdermountingblockrot;
bf210566 1661 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1662 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
1663 for(Int_t i=0; i<fgkflexnumber; i++){
1664 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1665 delete localflexmatrix[i][j];
1666 delete [] localflexmatrix[i];
1667 }
9b0c60ab 1668 delete localendlladdercoolingtuberot;
1669 for(Int_t i=0; i<2; i++){
1670 for(Int_t j=0; j<(i==0?6:4); j++)
1671 delete localendlladdercoolingtubetrans[i][j];
1672 delete [] localendlladdercoolingtubetrans[i];
1673 }
1674
bf210566 1675 delete localflexrot;
1676 delete localendflexrot;
1677 delete localendflexmatrix;
1678 for(Int_t i=0; i<fgkladdernumber; i++){
1679 delete localladdermothertrans[i];
1680 delete localladdermothercombitrans[i];
1681 }
1682 delete localladdermotherrot;
1683 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1684 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1685 delete localendladdercarbonfiberjunctionmatrix[i][j];
1686 delete localendladdercarbonfiberjunctionrot[i][j];
1687 delete localendladdercarbonfiberjunctiontrans[i][j];
1688 }
1689 delete [] localendladdercarbonfiberjunctionmatrix[i];
1690 delete [] localendladdercarbonfiberjunctionrot[i];
1691 delete [] localendladdercarbonfiberjunctiontrans[i];
1692 delete localendladdercarbonfiberjunctionglobalrot[i];
1693 delete localendladdercarbonfiberjunctionglobaltrans[i];
1694 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1695 }
9b0c60ab 1696 for(Int_t i=0; i<2; i++){
1697 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1698 delete [] localendladdercooltubetrans[i];
1699 }
1700 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1701 delete localendladdercarbonfibertrans[i];
1702 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1703 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1704 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1705 delete localladdercablecombitransmatrix[i][j];
1706 delete []localladdercablecombitransmatrix[i];
1707 }
9b0c60ab 1708 delete localendladdercliprot;
1709 delete localendladdercliptrans;
bf210566 1710 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1711 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1712 delete localladdercablehmatrix[i][j];
1713 delete []localladdercablehmatrix[i];
1714 }
1715 delete laddercablerot;
1716 delete laddercabletrans;
1717 delete laddercablecombitrans;
1718 delete localladdercablessdmodulematrix;
1719 delete localssdsensorrot;
1720 for(Int_t i=0; i<2; i++){
1721 delete localssdsensortrans[i];
1722 delete localssdsensorcombitrans[i];
1723 }
1724 for(Int_t i=0; i<fgklayernumber; i++){
1725 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1726 delete locallayerrot[i][j];
1727 delete locallayertrans[i][j];
1728 delete locallayercombitrans[i][j];
1729 }
1730 delete [] locallayerrot[i];
1731 delete [] locallayertrans[i];
1732 delete [] locallayercombitrans[i];
1733 delete localbeamaxistrans[i];
1734 }
1735 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1736 for(Int_t i=0; i<fgkladdernumber; i++){
1737 for(Int_t j=0; j<fgkladdernumber; j++)
1738 delete ladderglobalmatrix[i][j];
1739 delete [] ladderglobalmatrix[i];
1740 }
1741 /////////////////////////////////////////////////////////////
1742 fTransformationMatrices = kTRUE;
d7599219 1743}
bf210566 1744///////////////////////////////////////////////////////////////////////////////
1745void AliITSv11GeometrySSD::CreateBasicObjects(){
1746 /////////////////////////////////////////////////////////////
1747 // Method generating the Objects of SSD Geometry
1748 /////////////////////////////////////////////////////////////
1749 // SSD Sensor
1750 ///////////////////////////////////
1751 SetSSDSensor();
1752 /////////////////////////////////////////////////////////////
1753 // Carbon Fiber Support
1754 /////////////////////////////////////////////////////////////
1755 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1756 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1757 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1758 /////////////////////////////////////////////////////////////
bf210566 1759 // Carbon Fiber Junction
44285dfa 1760 /////////////////////////////////////////////////////////////
bf210566 1761 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
1762 /////////////////////////////////////////////////////////////
1763 // Carbon Fiber Lower Support
1764 /////////////////////////////////////////////////////////////
1765 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1766 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1767 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1768 /////////////////////////////
1769 // SSD Sensor Support
1770 /////////////////////////////
1771 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1772 new TGeoVolume*[fgkssdsensorsupportnumber];
44285dfa 1773 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
bf210566 1774 fgkSSDSensorSideSupportThickness[1]};
1775 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1776 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1777 fgkSSDSensorSideSupportHeight[i],
1778 fgkSSDSensorSideSupportWidth,
1779 sidesupporthickness);
1780 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1781 fgkSSDSensorCenterSupportHeight[i],
1782 fgkSSDSensorCenterSupportWidth,
1783 sidesupporthickness);
1784 }
1785 /////////////////////////////////////////////////////////////
1786 // SSD Cooling Tube Support
1787 /////////////////////////////////////////////////////////////
1788 Int_t edgesnumber = 16;
1789 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1790 /////////////////////////////////////////////////////////////
1791 // SSD Hybrid
1792 /////////////////////////////////////////////////////////////
1793 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1794 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1795 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1796 /////////////////////////////////////////////////////////////
1797 // SSD Cooling Block System
1798 /////////////////////////////////////////////////////////////
1799 fssdcoolingblocksystem = GetCoolingBlockSystem();
1800 /////////////////////////////////////////////////////////////
1801 // SSD Cooling Tube
1802 /////////////////////////////////////////////////////////////
1803 TList* coolingtubelist = GetCoolingTubeList();
1804 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
1805 fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
9b0c60ab 1806 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
1807 fendladdercoolingtube[i] =
1808 (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
bf210566 1809 /////////////////////////////////////////////////////////////
1810 // SSD Flex
1811 /////////////////////////////////////////////////////////////
1812 fssdstiffenerflex = GetSSDStiffenerFlex();
1813 fssdendflex = GetSSDEndFlex();
1814 ///////////////////////////////////
1815 // End Ladder Carbon Fiber Junction
1816 ///////////////////////////////////
1817 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1818 fendladdercarbonfiberjunction[i] =
1819 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1820 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1821 fendladdercarbonfiberjunction[i][0] =
1822 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
1823 fendladdercarbonfiberjunction[i][1] =
1824 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
1825 }
1826 ///////////////////////////////////
1827 // End Ladder Mounting Block
1828 ///////////////////////////////////
1829 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1830 ///////////////////////////////////
1831 // End Ladder Mounting Block
1832 ///////////////////////////////////
1833 fendladdermountingblockclip = GetMountingBlockClip();
1834 ///////////////////////////////////
1835 // Ladder Support
1836 ///////////////////////////////////
1837 TList* laddersupportlist = GetMountingBlockSupport(20);
1838 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1839 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1840 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1841 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
bf210566 1842 /////////////////////////////////////////////////////////////
1843 // Deallocating memory
44285dfa 1844 /////////////////////////////////////////////////////////////
bf210566 1845 delete carbonfibersupportlist;
1846 delete carbonfiberlowersupportlist;
1847 delete ssdhybridcomponentslist;
9b0c60ab 1848 delete laddersupportlist;
44285dfa 1849 /////////////////////////////////////////////////////////////
bf210566 1850 fBasicObjects = kTRUE;
1851}
1852/////////////////////////////////////////////////////////////////////////////////
1853void AliITSv11GeometrySSD::SetSSDSensor(){
1854 ////////////////////////////////////////////////////////////////
1855 // Method generating SSD Sensors: it sets the private variables
1856 // fSSDSensor5, fSSDSensor6
1857 ////////////////////////////////////////////////////////////////
44285dfa 1858 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1859 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1860 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
44285dfa 1861 0.5*ssdsensitivewidth,
bf210566 1862 0.5*fgkSSDSensorHeight,
1863 0.5*ssdsensitivelength);
1864 TGeoVolume* ssdsensorsensitiveLay5 =
1865 new TGeoVolume(fgSDDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
1866 TGeoVolume* ssdsensorsensitiveLay6 =
1867 new TGeoVolume(fgSDDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
1868 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1869 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
44285dfa 1870 TGeoBBox* ssdsensorinsensitiveshape[2];
1871 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1872 0.5*fgkSSDSensorInsensitiveWidth,
bf210566 1873 0.5*fgkSSDSensorHeight,
1874 0.5*fgkSSDSensorLength);
44285dfa 1875 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
44285dfa 1876 0.5*ssdsensitivewidth,
bf210566 1877 0.5*fgkSSDSensorHeight,
1878 0.5*fgkSSDSensorInsensitiveWidth);
44285dfa 1879 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1880 "SSDSensorInsensitive2"};
44285dfa 1881 TGeoVolume* ssdsensorinsensitive[2];
1882 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1883 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1884 fSSDSensorMedium);
1885 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1886 }
bf210566 1887 /////////////////////////////////////////////////////////////
1888 // Virtual Volume containing SSD Sensor
1889 /////////////////////////////////////////////////////////////
1890 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1891 0.5*fgkSSDSensorWidth,
1892 0.5*fgkSSDSensorHeight,
1893 0.5*fgkSSDSensorLength);
1894 fSSDSensor5 = new TGeoVolume("ITSsddSensor5",virtualSSDSensorShape,
1895 fSSDAir);
1896 fSSDSensor6 = new TGeoVolume("ITSsddSensor6",virtualSSDSensorShape,
1897 fSSDAir);
1898 /////////////////////////////////////////////////////////////
1899 for(Int_t i=0; i<4; i++){
1900 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1901 ssdsensorinsensitive[1],i<2?1:2,
1902 new TGeoTranslation(
1903 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1904 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1905 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1906 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1907 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
44285dfa 1908 ssdsensorinsensitive[1],i<2?1:2,
bf210566 1909 new TGeoTranslation(
1910 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1911 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1912 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1913 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1914 }
1915 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1916 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1917}
bf210566 1918///////////////////////////////////////////////////////////////////////////////
1919TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1920 /////////////////////////////////////////////////////////////
1921 // Method generating the Carbon Fiber Support
1922 /////////////////////////////////////////////////////////////
1923 const Int_t kvertexnumber = 4;
1924 const Int_t kshapesnumber = 2;
1925 TVector3** vertexposition[kshapesnumber];
1926 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1927 Double_t carbonfibersupportxaxisEdgeproj =
1928 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1929 * TMath::DegToRad());
1930 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1931 / fgkCarbonFiberSupportXAxisLength);
1932 /////////////////////
1933 //Vertex Positioning
1934 ////////////////////
1935 vertexposition[0][0] = new TVector3();
1936 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1937 fgkCarbonFiberSupportYAxisLength);
1938 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1939 carbonfibersupportxaxisEdgeproj
1940 * TMath::Tan(theta));
1941 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1942 - carbonfibersupportxaxisEdgeproj,
1943 fgkCarbonFiberSupportYAxisLength
1944 - vertexposition[0][2]->Y());
1945 ////////////////////////////////////////////////////
1946 //Setting the parameters for Isometry Transformation
1947 ////////////////////////////////////////////////////
1948 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1949 + fgkCarbonFiberSupportTopEdgeDist[0]
1950 + fgkCarbonFiberSupportWidth);
1951 Double_t* param = new Double_t[4];
1952 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1953 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1954 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1955 (GetReflection(vertexposition[0][j],param))->Y());
1956 char* carbonfibersupportshapename[kshapesnumber] =
1957 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1958 char* carbonfibersupportname[kshapesnumber] =
1959 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1960 TGeoArb8* carbonfibersupportshape[kshapesnumber];
1961 TGeoVolume* carbonfibersupport[kshapesnumber];
1962 TList* carbonfibersupportlist = new TList();
1963 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1964 Double_t carbonfibersupportheight =
1965 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1966 *TMath::DegToRad());
1967 for(Int_t i = 0; i< kshapesnumber; i++){
1968 carbonfibersupportshape[i] =
1969 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1970 carbonfibersupportshapename[i],i==0 ? 1: -1);
1971 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1972 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1973 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1974 carbonfibersupportlist->Add(carbonfibersupport[i]);
1975 }
1976 /////////////////////////////////////////////////////////////
1977 // Deallocating memory
1978 /////////////////////////////////////////////////////////////
1979 for(Int_t i=0; i< kshapesnumber; i++){
1980 for(Int_t j=0; j< kvertexnumber; j++)
1981 delete vertexposition[i][j];
1982 delete [] vertexposition[i];
1983 }
1984 delete [] param;
44285dfa 1985 /////////////////////////////////////////////////////////////
bf210566 1986 return carbonfibersupportlist;
d7599219 1987}
1988/////////////////////////////////////////////////////////////////////////////////
bf210566 1989TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 1990 /////////////////////////////////////////////////////////////
bf210566 1991 // Method generating SSD Carbon Fiber Junction
44285dfa 1992 /////////////////////////////////////////////////////////////
bf210566 1993 const Int_t kvertexnumber = 6;
1994 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
1995 Double_t reflectionparam[3] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1996 * TMath::DegToRad()),-1.,0.};
1997 TVector3* vertex[kvertexnumber];
1998 vertex[0] = new TVector3();
1999 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2000 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2001 * TMath::DegToRad()),
2002 fgkCarbonFiberJunctionEdge[0]
2003 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
2004 * TMath::DegToRad()));
2005 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
2006 fgkCarbonFiberJunctionEdge[1]);
2007 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
2008 vertex[1] = GetReflection(vertex[5],reflectionparam);
2009 vertex[2] = GetReflection(vertex[4],reflectionparam);
2010 Double_t xvertexpoints[6], yvertexpoints[6];
2011 for(Int_t i=0; i<kvertexnumber; i++)
2012 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
2013 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2014 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
2015 carbonfiberjunctionshape->DefineSection(1,0.5*width);
2016 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
2017 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
2018 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
2019 /////////////////////////////////////////////////////////////
2020 // Deallocating memory
2021 /////////////////////////////////////////////////////////////
2022 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
2023 /////////////////////////////////////////////////////////////
2024 return carbonfiberjunction;
2025}
2026////////////////////////////////////////////////////////////////////////////////
2027TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
2028 /////////////////////////////////////////////////////////////
2029 // Method generating the Carbon Fiber Lower Support
2030 /////////////////////////////////////////////////////////////
2031 const Int_t kvertexnumber = 4;
2032 const Int_t kshapesnumber = 2;
2033 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
2034 fgkCarbonFiberLowerSupportWidth};
2035 TVector3** vertexposition[kshapesnumber];
2036 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2037 new TVector3*[kvertexnumber];
2038 //First Shape Vertex Positioning
2039 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2040 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2041 - fgkCarbonFiberLowerSupportLowerLenght);
2042 vertexposition[0][2] = new TVector3();
2043 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2044 //Second Shape Vertex Positioning
2045 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2046 - fgkCarbonFiberLowerSupportVolumePosition[0])
2047 / fgkCarbonFiberTriangleLength);
2048 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2049 vertexposition[0][0]->X()*TMath::Tan(theta)
2050 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2051 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2052 vertexposition[0][1]->X()*TMath::Tan(theta)
2053 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2054 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2055 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2056 fgkCarbonFiberLowerSupportVolumePosition[1]);
2057 char* carbonfiberlowersupportshapename[kshapesnumber] =
2058 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
2059 char* carbonfiberlowersupportname[kshapesnumber] =
2060 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2061 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2062 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2063 TList* carbonfiberlowersupportlist = new TList();
2064 for(Int_t i = 0; i< kshapesnumber; i++){
2065 carbonfiberlowersupportshape[i] =
2066 GetArbShape(vertexposition[i],width,
2067 fgkCarbonFiberLowerSupportHeight,
2068 carbonfiberlowersupportshapename[i]);
2069 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2070 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2071 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2072 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2073 }
2074 /////////////////////////////////////////////////////////////
2075 // Deallocating memory
2076 /////////////////////////////////////////////////////////////
2077 for(Int_t i=0; i< kshapesnumber; i++){
2078 for(Int_t j=0; j< kvertexnumber; j++)
2079 delete vertexposition[i][j];
2080 delete [] vertexposition[i];
2081 }
2082 /////////////////////////////////////////////////////////////
2083 return carbonfiberlowersupportlist;
2084}
2085///////////////////////////////////////////////////////////////////////////////
2086TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2087 Double_t width, Double_t* thickness)const{
2088 /////////////////////////////////////////////////////////////
2089 // Method generating the Sensor Support
2090 /////////////////////////////////////////////////////////////
2091 const Int_t kvertexnumber = 6;
2092 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2093 TVector3* vertexposition[kvertexnumber];
2094 vertexposition[0] = new TVector3();
2095 vertexposition[1] = new TVector3(0.0,length);
2096 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2097 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2098 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2099 vertexposition[5] = new TVector3(vertexposition[4]->X());
2100 Double_t xvertexpoints[6], yvertexpoints[6];
2101 for(Int_t i=0; i<kvertexnumber; i++)
2102 xvertexpoints[i] = vertexposition[i]->X(),
2103 yvertexpoints[i] = vertexposition[i]->Y();
2104 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2105 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2106 ssdsensorsupportshape->DefineSection(1,0.5*width);
2107 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2108 ssdsensorsupportshape,fSSDSensorSupportMedium);
2109 /////////////////////////////////////////////////////////////
2110 // Deallocating memory
2111 /////////////////////////////////////////////////////////////
2112 for (Int_t i=0; i<kvertexnumber; i++)
2113 delete vertexposition[i];
2114 /////////////////////////////////////////////////////////////
2115 return ssdsensorsupport;
2116}
2117////////////////////////////////////////////////////////////////////////////////
2118TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2119 /////////////////////////////////////////////////////////////
2120 // Method generating the Cooling Tube Support
2121 /////////////////////////////////////////////////////////////
2122 if(nedges%2!=0) nedges--;
2123 const Int_t kvertexnumber = nedges+5;
2124 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2125 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2126 Double_t angle = 90.+phi;
2127 Double_t psi = 90.-phi;
2128 ///////////////////////////////////////
2129 // Vertex Positioning for TGeoXTru
2130 ///////////////////////////////////////
2131 TVector3** vertexposition = new TVector3*[kvertexnumber];
2132 vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
2133 fgkCoolingTubeSupportRmin*SinD(angle));
2134 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2135 fgkCoolingTubeSupportRmax*SinD(angle));
2136 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2137 fgkCoolingTubeSupportRmax);
2138 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2139 fgkCoolingTubeSupportRmax);
2140 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2141 vertexposition[1]->Y());
2142 for(Int_t i=0; i<nedges; i++)
2143 vertexposition[i+5] =
2144 new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
2145 fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
2146 ///////////////////////////////////////////////////////////////////////
2147 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2148 ///////////////////////////////////////////////////////////////////////
2149 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2150 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2151 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2152 for(Int_t i=0; i<kvertexnumber; i++){
2153 xvertexpoints[i] = vertexposition[i]->X();
2154 yvertexpoints[i] = vertexposition[i]->Y();
2155 }
2156 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2157 yvertexpoints);
2158 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2159 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2160 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2161 coolingtubesupportarcshape,
2162 fSSDTubeHolderMedium);
2163 coolingtubesupportarc->SetLineColor(fColorG10);
2164 //////////////////////////////////////////////////////////////////////////
2165 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2166 //////////////////////////////////////////////////////////////////////////
2167 TGeoTubeSeg* coolingtubesupportsegshape =
2168 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2169 fgkCoolingTubeSupportRmax,
2170 0.5*fgkCoolingTubeSupportWidth,
2171 phi,360-phi);
2172 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2173 coolingtubesupportsegshape,
2174 fSSDTubeHolderMedium);
2175 coolingtubesupportseg->SetLineColor(fColorG10);
2176 //////////////////////////////////////////////////////////////////////////
2177 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2178 //////////////////////////////////////////////////////////////////////////
2179 Double_t* boxorigin = new Double_t[3];
2180 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2181 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2182 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2183 0.5*fgkCoolingTubeSupportHeight,
2184 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2185 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2186 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2187 coolingtubesupportbox->SetLineColor(fColorG10);
2188 //////////////////////////////////////////////////////////////////////////
2189 // Cooling Tube for Cooling Tube Support
2190 //////////////////////////////////////////////////////////////////////////
2191 TGeoXtru* coolingtubearcshape[2];
2192 coolingtubearcshape[0] = new TGeoXtru(2);
2193 Double_t* xvert = new Double_t[nedges+2];
2194 Double_t* yvert = new Double_t[nedges+2];
2195 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2196 ////////////////////////////////////////
2197 // Positioning the vertices for TGeoXTru
2198 ////////////////////////////////////////
2199 xvert[0] = 0., yvert[0] = 0.;
2200 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2201 for(Int_t i=0; i< nedges; i++)
2202 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2203 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2204 ////////////////////////////////////////
2205 // Defining TGeoXTru PolyGone
2206 ////////////////////////////////////////
2207 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2208 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2209 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2210 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2211 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2212 TGeoVolume* coolingtubearc[2];
2213 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2214 coolingtubearcshape[0],fSSDCoolingTubeWater);
2215 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2216 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2217 coolingtubearc[0]->SetLineColor(fColorWater);
2218 coolingtubearc[1]->SetLineColor(fColorPhynox);
2219 ////////////////////////////////////////////
2220 // Defining TGeoTubeSeg Part of Cooling Tube
2221 ////////////////////////////////////////////
2222 TGeoTubeSeg* coolingtubesegshape[2];
2223 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2224 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2225 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2226 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2227 TGeoVolume* coolingtubeseg[2];
2228 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2229 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2230 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2231 coolingtubesegshape[1],fSSDCoolingTubeWater);
2232 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2233 coolingtubeseg[1]->SetLineColor(fColorWater);
2234 /////////////////////////////////////////////////////////////
2235 // Virtual Volume containing Cooling Tube Support
2236 /////////////////////////////////////////////////////////////
2237 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2238 const Int_t kvirtualvertexnumber = 8;
2239 TVector3* virtualvertex[kvirtualvertexnumber];
2240 ////////////////////////////////////////
2241 // Positioning the vertices for TGeoXTru
2242 ////////////////////////////////////////
2243 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2244 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2245 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2246 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2247 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2248 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2249 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2250 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2251 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2252 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2253 xmothervertex[i] = virtualvertex[i]->X(),
2254 ymothervertex[i] = virtualvertex[i]->Y();
2255 ////////////////////////////////////////
2256 // Defining TGeoXTru PolyGone
2257 ////////////////////////////////////////
2258 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2259 ymothervertex);
2260 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2261 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2262 TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2263 virtualCoolingTubeSupportShape,fSSDAir);
2264 ////////////////////////////////////////
2265 // Positioning Volumes in Virtual Volume
2266 ////////////////////////////////////////
2267 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2268 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2269 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2270 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2271 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2272 virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2273 virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2274 virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2275 virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2276 /////////////////////////////////////////////////////////////
2277 // Deallocating memory
2278 /////////////////////////////////////////////////////////////
2279 delete [] vertexposition;
2280 delete xvertexpoints;
2281 delete yvertexpoints;
2282 delete xvert;
2283 delete yvert;
2284 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2285 delete virtualvertex[i];
2286 /////////////////////////////////////////////////////////////
2287 return virtualcoolingtubesupport;
2288}
2289/////////////////////////////////////////////////////////////////////////////////
2290TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2291 /////////////////////////////////////////////////////////////
2292 // Method generating List containing SSD Hybrid Components
2293 /////////////////////////////////////////////////////////////
2294 TList* ssdhybridlist = new TList();
2295 const Int_t kssdstiffenernumber = 2;
2296 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2297 - 2.*fgkSSDModuleStiffenerPosition[1]
2298 - fgkSSDStiffenerWidth;
2299 Double_t ssdchipcablesradius[kssdstiffenernumber];
2300 for(Int_t i=0; i<kssdstiffenernumber; i++)
2301 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2302 - fgkSSDChipCablesHeight[0]
2303 - fgkSSDChipCablesHeight[1]);
2304 /////////////////////////////////////////////////////////////
2305 // Mother Volumes Containers
2306 /////////////////////////////////////////////////////////////
2307 const Int_t kmothernumber = 2;
2308 const Int_t kmothervertexnumber = 12;
2309 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2310 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2311 ///////////////////////
2312 // Setting the vertices
2313 ///////////////////////
2314 xmothervertex[0][0] = -0.5*fgkSSDStiffenerLength;
2315 xmothervertex[0][1] = xmothervertex[0][0];
2316 xmothervertex[0][2] = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
2317 xmothervertex[0][3] = xmothervertex[0][2];
2318 xmothervertex[0][4] = xmothervertex[0][0];
2319 xmothervertex[0][5] = xmothervertex[0][4];
2320 xmothervertex[0][6] = -xmothervertex[0][0];
2321 xmothervertex[0][7] = xmothervertex[0][6];
2322 xmothervertex[0][8] = -xmothervertex[0][2];
2323 xmothervertex[0][9] = xmothervertex[0][8];
2324 xmothervertex[0][10] = xmothervertex[0][7];
2325 xmothervertex[0][11] = xmothervertex[0][10];
2326 for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
2327 for(Int_t i = 0; i<kmothernumber; i++){
2328 ymothervertex[i][0] = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
2329 + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
2330 ymothervertex[i][1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
2331 ymothervertex[i][2] = ymothervertex[i][1];
2332 ymothervertex[i][3] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
2333 ymothervertex[i][4] = ymothervertex[i][3];
2334 ymothervertex[i][5] = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
2335 ymothervertex[i][6] = ymothervertex[i][5];
2336 ymothervertex[i][7] = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
2337 ymothervertex[i][8] = ymothervertex[i][7];
2338 ymothervertex[i][9] = 0.5*fgkSSDStiffenerWidth;
2339 ymothervertex[i][10] = ymothervertex[i][9];
2340 ymothervertex[i][11] = ymothervertex[i][0];
2341 }
2342 TGeoXtru* ssdhybridmothershape[kmothernumber];
2343 TGeoVolume* ssdhybridmother[kmothernumber];
2344 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2345 for(Int_t i=0; i<kmothernumber; i++){
2346 ssdhybridmothershape[i] = new TGeoXtru(2);
2347 ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
2348 ymothervertex[i]);
2349 ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2350 -fgkSSDChipCablesHeight[i+2]);
2351 ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
2352 ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
2353 fSSDAir);
2354 }
2355 /////////////////////////////////////////////////////////////
2356 // SSD Stiffener
2357 /////////////////////////////////////////////////////////////
2358 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2359 0.5*fgkSSDStiffenerLength,
2360 0.5*fgkSSDStiffenerWidth,
2361 0.5*fgkSSDStiffenerHeight);
2362 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2363 fSSDStiffenerMedium);
2364 ssdstiffener->SetLineColor(fColorStiffener);
2365 TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
2366 for(Int_t i=0; i<kssdstiffenernumber; i++)
2367 ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
2368 /////////////////////////////////////////////////////////////
2369 // SSD Chip System
2370 /////////////////////////////////////////////////////////////
2371 TList* ssdchipsystemlist = GetSSDChipSystem();
2372 Double_t ssdchipseparation = fgkSSDSensorLength
2373 - 2.*fgkSSDModuleStiffenerPosition[1]
2374 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
2375 - 0.5*fgkSSDChipWidth);
2376 Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
2377 + fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
2378 TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
2379 - 0.5*ssdchipsystemlength,
2380 0.5*(ssdstiffenerseparation-ssdchipseparation),
2381 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
2382////////////////////////////
2383// Capacitor 0603-2200 nF
2384///////////////////////////
2385 const Int_t knapacitor0603number = 5;
2386 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
2387 0.5*fgkSSDCapacitor0603Length,
2388 0.5*fgkSSDCapacitor0603Width,
2389 0.5*fgkSSDCapacitor0603Height);
2390 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2391 fSSDStiffener0603CapacitorMedium);
2392 capacitor0603->SetLineColor(fColorAl);
bf210566 2393 for(Int_t i=0; i<kmothernumber; i++){
2394 for(Int_t j=0; j<kssdstiffenernumber; j++){
2395 ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
2396 for(Int_t k=1; k<knapacitor0603number+1; k++){
2397 ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
2398 new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
2399 j*ssdstiffenerseparation
2400 + 0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
2401 + (j==0? -1:+1)*fgkSSDCapacitor0603Width),
2402 - 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
2403 }
2404 }
2405 ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
2406 ssdhybridlist->Add(ssdhybridmother[i]);
2407 }
2408/////////////////////////////////////////////////////////////
2409// Mother Volume Containing Capacitor Part
2410/////////////////////////////////////////////////////////////
2411 const Int_t kcapacitormothernumber = 8;
2412 Double_t xcapacitorvertex[kcapacitormothernumber];
2413 Double_t ycapacitorvertex[kcapacitormothernumber];
2414 ///////////////////////
2415 // Setting the vertices
2416 ///////////////////////
2417 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2418 xcapacitorvertex[1] = xcapacitorvertex[0];
2419 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2420 xcapacitorvertex[3] = xcapacitorvertex[2];
2421 xcapacitorvertex[4] = xcapacitorvertex[0];
2422 xcapacitorvertex[5] = xcapacitorvertex[0];
2423 xcapacitorvertex[6] = -xcapacitorvertex[0];
2424 xcapacitorvertex[7] = xcapacitorvertex[6];
2425 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2426 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2427 ycapacitorvertex[2] = ycapacitorvertex[1];
2428 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2429 ycapacitorvertex[4] = ycapacitorvertex[3];
2430 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2431 ycapacitorvertex[6] = ycapacitorvertex[5];
2432 ycapacitorvertex[7] = ycapacitorvertex[0];
2433 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2434 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2435 ycapacitorvertex);
2436 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2437 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2438 TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2439 fSSDAir);
d7599219 2440////////////////////////////
bf210566 2441// Connector
d7599219 2442///////////////////////////
bf210566 2443 const Int_t kssdconnectornumber = 2;
2444 TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2445 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2446 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2447 + fgkSSDConnectorAlHeight};
2448 const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2449 TGeoVolume* ssdconnector[kssdconnectornumber];
2450 for(Int_t i=0; i<kssdconnectornumber; i++){
2451 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2452 0.5*fgkSSDConnectorWidth,
2453 0.5*((1-i)*fgkSSDConnectorAlHeight
2454 + i*fgkSSDConnectorNiHeight),
2455 i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2456 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2457 i==0 ? fSSDAlTraceFlexMedium
2458 : fSSDStiffenerConnectorMedium);
2459 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2460 }
2461 TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2462 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2463 + fgkSSDConnectorPosition[0]
2464 - fgkSSDConnectorSeparation
2465 - 1.5*fgkSSDConnectorLength,
2466 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2467 - fgkSSDConnectorPosition[1]
2468 - ssdconnectorshape[0]->GetDY(),0.0);
2469 ssdconnectortrans[1] = new TGeoTranslation(
2470 - ssdstiffenershape->GetDX()
2471 + fgkSSDConnectorPosition[0]
2472 - 0.5*fgkSSDConnectorLength,
2473 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2474 - fgkSSDConnectorPosition[1]
2475 - ssdconnectorshape[0]->GetDY(),0.0);
2476 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2477 - fgkSSDConnectorPosition[0]
2478 + fgkSSDConnectorSeparation
2479 + 1.5*fgkSSDConnectorLength,
2480 -(ssdstiffenershape->GetDY()
2481 - fgkSSDConnectorPosition[1]
2482 - ssdconnectorshape[0]->GetDY()),0.0);
2483 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2484 - fgkSSDConnectorPosition[0]
2485 + 0.5*fgkSSDConnectorLength,
2486 -(ssdstiffenershape->GetDY()
2487 - fgkSSDConnectorPosition[1]
2488 - ssdconnectorshape[0]->GetDY()),0.0);
2489 for(Int_t i=0; i<2*kssdconnectornumber; i++)
2490 for(Int_t j=0; j<kssdconnectornumber; j++)
2491 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2492////////////////////////////
2493// Capacitor 1812-330 nF
2494///////////////////////////
2495 Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2496 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2497 0.5*fgkSSDCapacitor1812Length,
2498 0.5*fgkSSDCapacitor1812Width,
bf210566 2499 0.5*fgkSSDCapacitor1812Height,
2500 ssdcapacitor1812origin);
44285dfa 2501 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2502 fSSDStiffener1812CapacitorMedium);
2503 capacitor1812->SetLineColor(fColorAl);
bf210566 2504 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2505 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2506 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2507 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
d7599219 2508////////////////////////////
2509//Hybrid Wire
2510////////////////////////////
44285dfa 2511 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2512 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2513 - fgkSSDConnectorSeparation;
44285dfa 2514 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2515 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
44285dfa 2516 Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
2517 + TMath::Power(wirey,2));
2518 Double_t wireangle = TMath::ATan(wirex/wirey);
2519 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2520 fgkSSDWireRadius, 0.5*ssdwireradius);
2521 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2522 fSSDStiffenerHybridWireMedium);
2523 hybridwire->SetLineColor(fColorPhynox);
2524 TGeoCombiTrans* hybridwirecombitrans[2];
2525 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2526 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2527 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2528 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2529 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2530 ssdstiffenershape->GetDZ()
2531 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
d7599219 2532 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2533 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2534 0.0,
2535 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2536 0.0,
2537 new TGeoRotation("HybridWireRot2",
2538 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2539 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2540 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2541 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2542 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2543 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2544 /////////////////////////////////////////////////////////////
bf210566 2545 // Deallocating memory
44285dfa 2546 /////////////////////////////////////////////////////////////
bf210566 2547 delete hybridwirecombitrans[0];
2548 delete hybridwirecombitrans[1];
2549 delete ssdchipsystemlist;
2550 return ssdhybridlist;
2551 /////////////////////////////////////////////////////////////
2552}
2553///////////////////////////////////////////////////////////////////////////////
2554TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2555 /////////////////////////////////////////////////////////////
2556 // SSD Cooling Block System
2557 /////////////////////////////////////////////////////////////
2558 // SSD Cooling Block and Cooling Tube Transformations
2559 /////////////////////////////////////////////////////////////
2560 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2561 localcoolingblockrot->SetAngles(0.,90.,0.);
2562 TGeoCombiTrans* localcoolingblockmatrix =
2563 new TGeoCombiTrans(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
2564 TGeoTranslation* localcoolingblocktrans;
2565 TVector3* coolingblocktransvector;
2566 coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2567 + fgkSSDCoolingBlockLength,
2568 fgkSSDSensorLength
2569 - 2.*fgkSSDModuleStiffenerPosition[1]
2570 - fgkSSDCoolingBlockWidth);
2571 const Int_t kcoolingblocktransnumber = 2;
2572 const Int_t kcoolingblocknumber = 4;
2573 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2574 TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2575 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2576 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2577 TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2578 localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
2579 0.5*fgkSSDCoolingBlockWidth,
2580 fgkSSDCoolingBlockHoleCenter);
2581 TGeoCombiTrans* localcoolingtubematrix = new TGeoCombiTrans(*localcoolingtubetrans,
2582 *localcoolingtuberot);
2583 Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2584 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
2585 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2586 localcoolingblocktrans=
2587 new TGeoTranslation(i*coolingblocktransvector->X()+2*coolingtubedistance,
2588 j*coolingblocktransvector->Y(),
2589 - 0.5*(fgkSSDCoolingBlockHoleCenter
2590 + fgkCoolingTubeRmax));
2591 coolingblockmatrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
2592 *(*localcoolingblockmatrix));
2593 coolingtubematrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
2594 *(*localcoolingtubematrix));
2595 }
d7599219 2596 }
bf210566 2597 /////////////////////////////////////////////////////////////
2598 // Virtual Volume containing CoolingBlock System
2599 /////////////////////////////////////////////////////////////
2600 TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2601 const Int_t kmothervertexnumber = 16;
2602 Double_t xmothervertex[kmothervertexnumber];
2603 Double_t ymothervertex[kmothervertexnumber];
2604 ///////////////////////
2605 // Setting the vertices
2606 ///////////////////////fgkCoolingTubeSupportRmax
2607 xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2608 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2609 + fgkSSDCoolingBlockWidth;
2610 xmothervertex[2] = coolingblocktransvector->X()
2611 + fgkSSDCoolingBlockLength
2612 + 4*coolingtubedistance;
2613 ymothervertex[2] = ymothervertex[1];
2614 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2615 xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2616 ymothervertex[4] = ymothervertex[0];
2617 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2618 xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2619 ymothervertex[6] = ymothervertex[5];
2620 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2621 - fgkSSDCoolingBlockWidth;
2622 xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2623 xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2624 - coolingtubedistance;
2625 xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2626 ymothervertex[10] = ymothervertex[9];
2627 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2628 xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2629 xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2630 xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2631 ymothervertex[14] = ymothervertex[13];
2632 xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2633 //////////////////////////////////////////////////////////
2634 coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2635 xmothervertex,ymothervertex);
2636 coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2637 + fgkCoolingTubeRmax));
2638 coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2639 + fgkCoolingTubeRmax));
2640 TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
2641 coolingsystemothershape,fSSDAir);
2642 /////////////////////////////////////////////////////////////
2643 // SSD Cooling Tube Part
2644 /////////////////////////////////////////////////////////////
2645 TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
2646 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2647 0.5*fgkSSDCoolingBlockWidth);
2648 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
2649 0.5*fgkSSDCoolingBlockWidth);
2650 TGeoVolume* coolingtube[fgkcoolingtubenumber];
2651 coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
2652 fSSDCoolingTubePhynox);
2653 coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
2654 fSSDCoolingTubeWater);
2655 coolingtube[0]->SetLineColor(fColorPhynox);
2656 coolingtube[1]->SetLineColor(fColorWater);
2657 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2658 /////////////////////////////////////////////////////////////
2659 // Adding Cooling block to mother volume
2660 /////////////////////////////////////////////////////////////
2661 for(Int_t i=0; i<kcoolingblocknumber; i++){
2662 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2663 coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
2664 coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
d7599219 2665 }
bf210566 2666 /////////////////////////////////////////////////////////////
2667 // Deallocating memory
2668 /////////////////////////////////////////////////////////////
2669 delete coolingblocktransvector;
2670 delete localcoolingblocktrans;
2671 delete localcoolingblockrot;
2672 delete localcoolingblockmatrix;
2673 delete localcoolingtubetrans;
2674 delete localcoolingtuberot;
2675 /////////////////////////////////////////////////////////////
2676 // Checking overlaps
2677 /////////////////////////////////////////////////////////////
9b0c60ab 2678 coolingsystemother->CheckOverlaps(0.01);
bf210566 2679 /////////////////////////////////////////////////////////////
2680 return coolingsystemother;
d7599219 2681}
2682/////////////////////////////////////////////////////////////////////////////////
bf210566 2683TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2684 /////////////////////////////////////////////////////////////
bf210566 2685 // SSD Flex
44285dfa 2686 /////////////////////////////////////////////////////////////
bf210566 2687 const Int_t kssdflexlayernumber = 2;
2688 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2689 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2690 const Int_t kmothervertexnumber = 17;
2691 Double_t xmothervertex[kmothervertexnumber];
2692 Double_t ymothervertex[kmothervertexnumber];
2693 /////////////////////////////////////////////
2694 // Auxiliary variables for vertex positioning
2695 /////////////////////////////////////////////
2696 const Int_t kssdflexboxnumber = 5;
44285dfa 2697 Double_t ssdflexboxlength[kssdflexboxnumber];
2698 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2699 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2700 * fgkSSDChipSeparationLength
2701 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2702 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2703 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2704 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2705 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2706 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2707 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2708 - ssdflexboxlength[1];
44285dfa 2709 Double_t ssdflexboxwidth[kssdflexboxnumber];
2710 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2711 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2712 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2713 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2714 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2715 ///////////////////////
2716 // Setting the vertices
2717 ///////////////////////
2718 xmothervertex[0] = 0.0;
2719 xmothervertex[1] = xmothervertex[0];
2720 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2721 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2722 + ssdflexboxlength[4];
2723 xmothervertex[4] = xmothervertex[3];
2724 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2725 xmothervertex[6] = xmothervertex[5];
2726 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2727 xmothervertex[8] = xmothervertex[7];
2728 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2729 xmothervertex[10] = xmothervertex[9];
2730 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2731 xmothervertex[12] = xmothervertex[11];
2732 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2733 xmothervertex[14] = xmothervertex[13];
2734 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2735 xmothervertex[16] = xmothervertex[15];
2736 ymothervertex[0] = 0.0;
2737 ymothervertex[1] = fgkSSDFlexWidth[1];
2738 ymothervertex[2] = fgkSSDFlexWidth[0];
2739 ymothervertex[3] = ymothervertex[2];
2740 ymothervertex[4] = ymothervertex[0];
2741 ymothervertex[5] = ymothervertex[4];
2742 ymothervertex[6] = ssdflexboxwidth[2];
2743 ymothervertex[7] = ymothervertex[6];
2744 ymothervertex[8] = ymothervertex[0];
2745 ymothervertex[9] = ymothervertex[8];
2746 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2747 ymothervertex[11] = ymothervertex[10];
2748 ymothervertex[12] = ymothervertex[0];
2749 ymothervertex[13] = ymothervertex[12];
2750 ymothervertex[14] = ymothervertex[7];
2751 ymothervertex[15] = ymothervertex[14];
2752 ymothervertex[16] = ymothervertex[0];
2753 /////////////////////////////////////////////////////////////
2754 // First Mother Volume containing SSDFlex
2755 /////////////////////////////////////////////////////////////
2756 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2757 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2758 ymothervertex);
2759 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2760 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2761 TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2762 fSSDAir);
2763 /////////////////////////////////////////////////////////////
2764 // SSDFlex Layer Shapes
2765 /////////////////////////////////////////////////////////////
2766 for(Int_t i=0; i<kssdflexlayernumber; i++){
2767 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2768 ymothervertex);
2769 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2770 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2771 }
2772 /////////////////////////////////////
2773 // Setting Layers into Mother Volume
2774 /////////////////////////////////////
2775 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2776 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2777 fSSDKaptonFlexMedium};
2778 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2779 "AlFlexLay2","KaptonFlexLay2"};
2780 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2781 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2782 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2783 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2784 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2785 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2786 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2787 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2788 + fgkSSDFlexHeight[1]));
2789 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2790 }
9b0c60ab 2791 ssdflexmother->CheckOverlaps(0.01);
bf210566 2792 return ssdflexmother;
d7599219 2793}
2794/////////////////////////////////////////////////////////////////////////////////
bf210566 2795TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2796 /////////////////////////////////////////////////////////////
2797 // Method generating SSD End Flex
d7599219 2798 /////////////////////////////////////////
bf210566 2799 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2800 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2801 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2802 * TMath::DegToRad()*ssdflexradiusmax
2803 - fgkSSDFlexLength[2]-TMath::Pi()
2804 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
2805 const Int_t knedges = 20;
2806 const Int_t karcnumber = 2;
2807 TVector3* vertexposition[karcnumber*(knedges+1)];
2808 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2809 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2810 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2811 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2812 - 90.0*TMath::DegToRad()};
2813 TVector3* referencetrans[karcnumber];
2814 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2815 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2816 radius[0]);
2817 referencetrans[1] = new TVector3(referencetrans[0]->X()
2818 + fgkSSDFlexLength[2],
2819 - fgkSSDStiffenerHeight);
2820for(Int_t i=0; i<karcnumber; i++){
2821 for(Int_t j=0; j<knedges+1; j++){
2822 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2823 radius[i]*SinD(angle[i]));
2824 angle[i] += deltangle[i]*(1.0-2.0*i);
2825 }
2826 }
2827 ///////////////////////
2828 // Setting the vertices
2829 ///////////////////////
2830 const Int_t kendflexlayernumber = 4;
2831 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2832 TVector3** vertex[kendflexlayernumber];
2833 for(Int_t i=0; i<kendflexlayernumber; i++)
2834 vertex[i] = new TVector3*[kendflexvertexnumber];
2835 TVector3* transvector[kendflexlayernumber+1];
2836 TVector3* deltatransvector = new TVector3();
2837 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2838 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2839 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2840 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2841 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2842 * CosD(fgkSSDFlexAngle),
2843 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2844 * SinD(fgkSSDFlexAngle),0.0);
2845 *transvector[i] = *transvector[i-1]+*deltatransvector;
2846 }
2847 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2848 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2849 for(Int_t i=0; i<karcnumber; i++){
2850 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2851 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2852 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2853 /radius[i];
2854 }
2855 }
2856 for(Int_t i=0; i<kendflexlayernumber; i++){
2857 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2858 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2859 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2860 if(j<(knedges+1)){
2861 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2862 vertexposition[j]->Y()*ratioradius[0][i+1]);
2863 vertex[i][j+2]->RotateZ(referenceangle[0]);
2864 *vertex[i][j+2] += *referencetrans[0];
2865 vertex[i][4*(knedges+1)-j+1] =
2866 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2867 vertexposition[j]->Y()*ratioradius[0][i]);
2868 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2869 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2870 }
2871 else{
2872
2873 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2874 vertexposition[j]->Y()*ratioradius[1][i+1]);
2875 vertex[i][j+2]->RotateZ(referenceangle[1]);
2876 *vertex[i][j+2] += *referencetrans[1];
2877 vertex[i][4*(knedges+1)-j+1] =
2878 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2879 vertexposition[j]->Y()*ratioradius[1][i]);
2880 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2881 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2882 }
2883 }
2884 }
44285dfa 2885 /////////////////////////////////////////////////////////////
bf210566 2886 // First Mother Volume containing SSDEndFlex
2887 /////////////////////////////////////////////////////////////
2888 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2889 Double_t xmothervertex[kendflexvertexnumber];
2890 Double_t ymothervertex[kendflexvertexnumber];
2891 xmothervertex[0] = vertex[0][0]->X();
2892 ymothervertex[0] = vertex[0][0]->Y();
2893 for(Int_t i=1; i<kendflexvertexnumber; i++){
2894 if(i<2*(knedges+1)+2){
2895 xmothervertex[i] = vertex[3][i]->X();
2896 ymothervertex[i] = vertex[3][i]->Y();
2897 }
2898 else{
2899 xmothervertex[i] = vertex[0][i]->X();
2900 ymothervertex[i] = vertex[0][i]->Y();
2901 }
2902 }
2903 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2904 xmothervertex,ymothervertex);
2905 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2906 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2907 TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2908 ssdendflexmothershape,fSSDAir);
2909 //////////////////////////////////////
2910 // End Flex TGeoXtru Layer Definition
2911 //////////////////////////////////////
2912 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2913 TGeoVolume* ssdendflex[kendflexlayernumber];
2914 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2915 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2916 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2917 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2918 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2919 fSSDKaptonFlexMedium};
2920 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2921 "AlEndFlexLay2","KaptonEndFlexLay2"};
2922 for(Int_t i=0; i<kendflexlayernumber; i++){
2923 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2924 xvertex[i][j] = vertex[i][j]->X();
2925 yvertex[i][j] = vertex[i][j]->Y();
2926 }
2927 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2928 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2929 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2930 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2931 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2932 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2933 ssdendflexmother->AddNode(ssdendflex[i],1);
2934 }
44285dfa 2935 /////////////////////////////////////////////////////////////
bf210566 2936 // Deallocating memory
44285dfa 2937 /////////////////////////////////////////////////////////////
bf210566 2938 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2939 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2940 for(Int_t i=0; i<kendflexlayernumber; i++){
2941 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2942 delete [] vertex[i];
2943 }
2944 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2945 delete deltatransvector;
44285dfa 2946 /////////////////////////////////////////////////////////////
9b0c60ab 2947 ssdendflexmother->CheckOverlaps(0.01);
bf210566 2948 return ssdendflexmother;
d7599219 2949}
9b0c60ab 2950///////////////////////////////////////////////////////////////////////////////
bf210566 2951TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 2952 /////////////////////////////////////////////////////////////
9b0c60ab 2953 // Method generating the Mounting Block
bf210566 2954 /////////////////////////////////////////////////////////////
9b0c60ab 2955 const Int_t kvertexnumber = 8;
2956 Double_t xvertex[kvertexnumber];
2957 Double_t yvertex[kvertexnumber];
2958 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2959 xvertex[1] = xvertex[0];
2960 xvertex[2] = -xvertex[0];
2961 xvertex[3] = xvertex[2];
2962 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2963 - fgkSSDMountingBlockLength[2]);
2964 xvertex[5] = xvertex[4];
2965 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2966 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2967 - fgkSSDMountingBlockScrewHoleRadius[0];
2968 xvertex[7] = xvertex[6];
2969 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
2970 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
2971 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2972 yvertex[2] = yvertex[1];
2973 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2974 yvertex[4] = yvertex[3];
2975 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2976 - fgkSSDMountingBlockHeight[0];
2977 yvertex[6] = yvertex[5];
2978 yvertex[7] = yvertex[0];
2979 ///////////////////////////////////////////////////////////////////////
2980 // TGeoXTru Volume definition for Mounting Block Part
2981 ///////////////////////////////////////////////////////////////////////
2982 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2983 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2984 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2985 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 2986 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 2987 ssdmountingblockshape,
2988 fSSDMountingBlockMedium);
2989 ssdmountingblock->SetLineColor(fColorG10);
2990 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2991 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2992 TGeoRotation* mountingblockrot = new TGeoRotation();
2993 mountingblockrot->SetAngles(90.,180.,-90.);
2994 mountingblockcombitrans->SetRotation(*mountingblockrot);
2995 /////////////////////////////////////////////////////////////
2996 // Generating the Mounting Block Screw Vertices
2997 /////////////////////////////////////////////////////////////
2998 const Int_t kscrewvertexnumber = 15;
2999 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
3000 - fgkSSDMountingBlockScrewHoleEdge)
3001 / fgkSSDMountingBlockScrewHoleRadius[0])
3002 * TMath::RadToDeg();
3003 Double_t phi0 = 90.+alpha;
3004 Double_t phi = 270.-2*alpha;
3005 Double_t deltaphi = phi/kscrewvertexnumber;
3006 TVector3* screwvertex[kscrewvertexnumber+1];
3007 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
3008 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
3009 *CosD(phi0+i*deltaphi),
3010 fgkSSDMountingBlockScrewHoleRadius[0]
3011 *SinD(phi0+i*deltaphi));
3012 Double_t xscrewvertex[kscrewvertexnumber+6];
3013 Double_t yscrewvertex[kscrewvertexnumber+6];
3014 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
3015 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
3016 - fgkSSDMountingBlockScrewHoleEdge);
3017 xscrewvertex[1] = xscrewvertex[0];
3018 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3019 xscrewvertex[2] = screwvertex[0]->X();
3020 yscrewvertex[2] = yscrewvertex[1];
3021 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
3022 xscrewvertex[i+3] = screwvertex[i]->X();
3023 yscrewvertex[i+3] = screwvertex[i]->Y();
3024 }
3025 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3026 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
3027 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
3028 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
3029 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
3030 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
3031 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
3032 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
3033 + fgkSSDMountingBlockHeight[2]);
3034 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
3035 ssdmountingblockscrewshape,
3036 fSSDMountingBlockMedium);
3037 ssdmountingblockscrew->SetLineColor(fColorG10);
3038 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
3039 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
3040 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3041 - yscrewvertex[1],
3042 0.5*fgkSSDMountingBlockHeight[0]
3043 - fgkSSDMountingBlockHeight[2]
3044 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3045 + fgkSSDMountingBlockHeight[2]
3046 - yvertex[0]));
3047 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3048 -0.5*fgkSSDMountingBlockScrewHoleEdge,
3049 yscrewvertex[1]
3050 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3051 +fgkSSDMountingBlockHeight[2]
3052 -yvertex[0]));
3053 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3054 yscrewvertex[1],
3055 - 0.5*fgkSSDMountingBlockHeight[0]
3056 + fgkSSDMountingBlockHeight[2]
3057 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3058 + fgkSSDMountingBlockHeight[2]
3059 - yvertex[0]));
3060 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3061 yscrewvertex[1],
3062 - yscrewvertex[1]
3063 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3064 + fgkSSDMountingBlockHeight[2]
3065 - yvertex[0]));
3066 TGeoRotation* ssdmountingblockscrewrot[4];
3067 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3068 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3069 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3070 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3071 for(Int_t i=1; i<4; i++)
3072 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3073 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3074 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3075 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3076 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3077 + xvertex[0],yscrewvertex[1]
3078 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3079 + fgkSSDMountingBlockHeight[2]
3080 - yvertex[0]),0.);
3081 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3082 for(Int_t i=0; i<4; i++){
3083 ssdmountingblockscrewmatrix[i] =
3084 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3085 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3086 }
3087 ///////////////////////////////////////////////////////////////////////
3088 // TGeoXtru for Mother Volume
3089 ///////////////////////////////////////////////////////////////////////
3090 const Int_t kvertexmothernumber = 12;
3091 Double_t xmothervertex[kvertexmothernumber];
3092 Double_t ymothervertex[kvertexmothernumber];
3093 for(Int_t i=0; i<6; i++){
3094 xmothervertex[i] = xvertex[i];
3095 ymothervertex[i] = yvertex[i];
3096 }
3097 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3098 ymothervertex[6] = ymothervertex[5];
3099 xmothervertex[7] = xmothervertex[6];
3100 ymothervertex[7] = ymothervertex[4];
3101 xmothervertex[8] = xmothervertex[7]
3102 + 0.5*(fgkSSDMountingBlockLength[1]
3103 - fgkSSDMountingBlockLength[2]);
3104 ymothervertex[8] = ymothervertex[4];
3105 xmothervertex[9] = xmothervertex[8];
3106 ymothervertex[9] = ymothervertex[2];
3107 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3108 ymothervertex[10] = ymothervertex[1];
3109 xmothervertex[11] = xmothervertex[10];
3110 ymothervertex[11] = ymothervertex[0];
3111 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3112 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3113 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3114 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3115 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3116 ssdmountingblockmothershape,
3117 fSSDAir);
3118 /////////////////////////////////////////////////////////////
3119 // Placing the Volumes into Mother Volume
3120 /////////////////////////////////////////////////////////////
3121 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3122 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3123 for(Int_t i=0; i<4; i++)
3124 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3125 ssdmountingblockscrewmatrix[i]);
3126 /////////////////////////////////////////////////////////////
3127 // Deallocating memory
3128 /////////////////////////////////////////////////////////////
3129 delete mountingblockrot;
3130 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3131 delete ssdmountingblockglobalrot;
3132 delete ssdmountingblockglobaltrans;
3133 /////////////////////////////////////////////////////////////
3134 return ssdmountingblockmother;
3135}
3136///////////////////////////////////////////////////////////////////////////////
3137 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3138 /////////////////////////////////////////////////////////////
3139 // Method generating the Mounting Block Clip
3140 /////////////////////////////////////////////////////////////
3141 const Int_t kmothervertexnumber = 10;
3142 Double_t xmothervertex[kmothervertexnumber];
3143 Double_t ymothervertex[kmothervertexnumber];
3144 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3145 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3146 xmothervertex[1] = xmothervertex[0];
3147 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3148 - fgkMountingBlockClibScrewRadius);
3149 xmothervertex[3] = xmothervertex[2];
3150 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3151 xmothervertex[5] = xmothervertex[4];
3152 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3153 xmothervertex[7] = xmothervertex[6];
3154 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3155 xmothervertex[9] = xmothervertex[8];
3156 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
3157 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
3158 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3159 ymothervertex[2] = ymothervertex[1];
3160 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3161 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3162 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3163 ymothervertex[4] = ymothervertex[3];
3164 ymothervertex[5] = ymothervertex[2];
3165 ymothervertex[6] = ymothervertex[5];
3166 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3167 ymothervertex[8] = ymothervertex[7];
3168 ymothervertex[9] = ymothervertex[0];
3169 ///////////////////////////////////////////////////////////////////////
3170 // TGeoXTru Volume definition for Mounting Block Clip Part
3171 ///////////////////////////////////////////////////////////////////////
3172 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3173 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3174 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3175 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3176 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3177 ssdmountingblockclipshape,fSSDAir);
3178 ssdmountingblockclip->SetLineColor(4);
3179 ///////////////////////////////////////////////////////////////////////
3180 // TGeoXTru Volume definition for Clip
3181 ///////////////////////////////////////////////////////////////////////
3182 const Int_t kclipvertexnumber = 6;
3183 Double_t xclipvertex[kclipvertexnumber];
3184 Double_t yclipvertex[kclipvertexnumber];
3185 xclipvertex[0] = xmothervertex[0];
3186 xclipvertex[1] = xclipvertex[0];
3187 xclipvertex[2] = xmothervertex[6];
3188 xclipvertex[3] = xclipvertex[2];
3189 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3190 xclipvertex[5] = xclipvertex[4];
3191 yclipvertex[0] = ymothervertex[0];
3192 yclipvertex[1] = ymothervertex[1];
3193 yclipvertex[2] = yclipvertex[1];
3194 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3195 yclipvertex[4] = yclipvertex[3];
3196 yclipvertex[5] = yclipvertex[0];
3197 TGeoXtru* clipshape = new TGeoXtru(2);
3198 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3199 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3200 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3201 + fgkMountingBlockClibWidth);
3202 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3203 clip->SetLineColor(18);
3204 ///////////////////////////////////////////////////////////////////////
3205 // Ladder Support Piece
3206 ///////////////////////////////////////////////////////////////////////
3207 const Int_t ksupportvertexnumber = 4;
3208 Double_t xsupportvertex[ksupportvertexnumber];
3209 Double_t ysupportvertex[ksupportvertexnumber];
3210 xsupportvertex[0] = xclipvertex[5];
3211 xsupportvertex[1] = xsupportvertex[0];
3212 xsupportvertex[2] = xmothervertex[9];
3213 xsupportvertex[3] = xsupportvertex[2];
3214 ysupportvertex[0] = yclipvertex[0];
3215 ysupportvertex[1] = yclipvertex[3];
3216 ysupportvertex[2] = ysupportvertex[1];
3217 ysupportvertex[3] = ysupportvertex[0];
3218 TGeoXtru* supportshape = new TGeoXtru(2);
3219 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3220 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3221 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3222 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3223 support->SetLineColor(9);
3224 ///////////////////////////////////////////////////////////////////////
3225 // TGeoXTru Volume definition for Screw
3226 ///////////////////////////////////////////////////////////////////////
3227 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3228 0.5*fgkMountingBlockClibScrewRadius};
3229 Int_t edgesnumber[2] = {50,6};
3230 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3231 +0.5*(ymothervertex[3]-ymothervertex[2])};
3232 TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3233 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3234 clipscrew->SetLineColor(12);
3235 TGeoRotation* screwrot = new TGeoRotation();
3236 screwrot->SetAngles(0.,90.,0.);
3237 TGeoTranslation* screwtrans = new TGeoTranslation();
3238 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3239 0.5*(ymothervertex[3]+ymothervertex[2]),
3240 0.5*fgkSSDMountingBlockWidth+
3241 -0.5*fgkMountingBlockSupportWidth[0]);
3242 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3243 ///////////////////////////////////////////////////////////////////////
3244 // Placing the Volumes
3245 ///////////////////////////////////////////////////////////////////////
3246 ssdmountingblockclip->AddNode(clip,1);
3247 ssdmountingblockclip->AddNode(support,1);
3248 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3249 /////////////////////////////////////////////////////////////
3250 // Deallocating memory
3251 /////////////////////////////////////////////////////////////
3252 delete screwtrans;
3253 delete screwrot;
3254 /////////////////////////////////////////////////////////////
3255 return ssdmountingblockclip;
d7599219 3256}
bf210566 3257///////////////////////////////////////////////////////////////////////////////
3258TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
44285dfa 3259 /////////////////////////////////////////////////////////////
bf210566 3260 // Method generating the Cooling Tube
44285dfa 3261 /////////////////////////////////////////////////////////////
bf210566 3262 TGeoTube** coolingtubeshape[fgkcoolingtubenumber];
3263 for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtubeshape[i] =
3264 new TGeoTube*[2];
9b0c60ab 3265 // Ladder Cooling Tubes
bf210566 3266 coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3267 0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3268 - 2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth));
3269 coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3270 coolingtubeshape[0][0]->GetDz());
3271 coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3272 0.5*(fgkSSDModuleStiffenerPosition[1]
3273 - fgkSSDSensorOverlap));
3274 coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3275 coolingtubeshape[1][0]->GetDz());
3276 coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3277 0.5*fgkSSDModuleStiffenerPosition[1]);
3278 coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3279 coolingtubeshape[2][0]->GetDz());
9b0c60ab 3280 // End Ladder Cooling Tubes
3281 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3282 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3283 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3284 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3285 0.50 * (fgkEndLadderMountingBlockPosition[0]
3286 - fgkendladdercoolingsupportdistance[0]));
3287 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3288 endladdercoolingtubeshape[0][0]->GetDz());
3289 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3290 0.50 * (fgkendladdercoolingsupportdistance[0]
3291 + fgkendladdercoolingsupportdistance[1]
3292 - fgkCoolingTubeSupportWidth));
3293 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3294 endladdercoolingtubeshape[1][0]->GetDz());
3295 endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3296 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
3297 - fgkEndLadderMountingBlockPosition[0]
3298 - fgkendladdercoolingsupportdistance[1]
3299 - fgkCoolingTubeSupportWidth));
3300 endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3301 endladdercoolingtubeshape[2][0]->GetDz());
3302 endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3303 0.50 * (fgkMountingBlockToSensorSupport
3304 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
3305 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
3306 + fgkSSDSensorOverlap
3307 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
3308 - fgkendladdercoolingsupportdistance[2]
3309 - fgkEndLadderMountingBlockPosition[1]
3310 - fgkCoolingTubeSupportWidth));
3311 endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3312 endladdercoolingtubeshape[3][0]->GetDz());
3313 endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3314 0.50 * fgkendladdercoolingsupportdistance[2]);
3315 endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3316 endladdercoolingtubeshape[4][0]->GetDz());
3317 // Ladder Cooling Tubes
bf210566 3318 TGeoVolume** coolingtube[fgkcoolingtubenumber];
3319 for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtube[i] =
3320 new TGeoVolume*[2];
3321 coolingtube[0][0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0][0],
3322 fSSDCoolingTubePhynox);
3323 coolingtube[0][1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[0][1],
3324 fSSDCoolingTubeWater);
3325 coolingtube[1][0] = new TGeoVolume("OuterCoolingTube2",coolingtubeshape[1][0],
3326 fSSDCoolingTubePhynox);
3327 coolingtube[1][1] = new TGeoVolume("InnerCoolingTube2",coolingtubeshape[1][1],
3328 fSSDCoolingTubeWater);
3329 coolingtube[2][0] = new TGeoVolume("OuterCoolingTube3",coolingtubeshape[2][0],
3330 fSSDCoolingTubePhynox);
3331 coolingtube[2][1] = new TGeoVolume("InnerCoolingTube3",coolingtubeshape[2][1],
3332 fSSDCoolingTubeWater);
3333 for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3334 coolingtube[i][0]->SetLineColor(fColorPhynox);
3335 coolingtube[i][1]->SetLineColor(fColorWater);
3336 }
9b0c60ab 3337 // End Ladder Cooling Tubes
3338 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3339 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3340 endladdercoolingtube[i] = new TGeoVolume*[2];
3341 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3342 endladdercoolingtubeshape[0][0],
3343 fSSDCoolingTubePhynox);
3344 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3345 endladdercoolingtubeshape[0][1],
3346 fSSDCoolingTubeWater);
3347 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3348 endladdercoolingtubeshape[1][0],
3349 fSSDCoolingTubePhynox);
3350 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3351 endladdercoolingtubeshape[1][1],
3352 fSSDCoolingTubeWater);
3353 endladdercoolingtube[2][0] = new TGeoVolume("OuterEndLadderCoolingTube3",
3354 endladdercoolingtubeshape[2][0],
3355 fSSDCoolingTubePhynox);
3356 endladdercoolingtube[2][1] = new TGeoVolume("InnerEndlLadderCoolingTube3",
3357 endladdercoolingtubeshape[2][1],
3358 fSSDCoolingTubeWater);
3359 endladdercoolingtube[3][0] = new TGeoVolume("OuterEndLadderCoolingTube4",
3360 endladdercoolingtubeshape[3][0],
3361 fSSDCoolingTubePhynox);
3362 endladdercoolingtube[3][1] = new TGeoVolume("InnerEndlLadderCoolingTube4",
3363 endladdercoolingtubeshape[3][1],
3364 fSSDCoolingTubeWater);
3365 endladdercoolingtube[4][0] = new TGeoVolume("OuterEndLadderCoolingTube5",
3366 endladdercoolingtubeshape[4][0],
3367 fSSDCoolingTubePhynox);
3368 endladdercoolingtube[4][1] = new TGeoVolume("InnerEndlLadderCoolingTube5",
3369 endladdercoolingtubeshape[4][1],
3370 fSSDCoolingTubeWater);
3371 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3372 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3373 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3374 }
bf210566 3375 /////////////////////////////////////////////////////////////
3376 // Virtual Volume containing Cooling Tubes
3377 /////////////////////////////////////////////////////////////
9b0c60ab 3378 // Ladder Cooling Tubes
bf210566 3379 TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber];
3380 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
3381 virtualcoolingtubeshape[i] = new TGeoTube(coolingtubeshape[i][1]->GetRmin(),
3382 coolingtubeshape[i][0]->GetRmax(),
3383 coolingtubeshape[i][0]->GetDz());
3384 TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber];
3385 virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0],
3386 fSSDAir);
3387 virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1],
3388 fSSDAir);
3389 virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2],
3390 fSSDAir);
9b0c60ab 3391 // End Ladder Cooling Tubes
3392 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3393 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3394 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3395 endladdercoolingtubeshape[i][0]->GetRmax(),
3396 endladdercoolingtubeshape[i][0]->GetDz());
3397 TGeoVolume* endladdervirtualcoolingtube[fgkendladdercoolingtubenumber];
3398 endladdervirtualcoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3399 endladdervirtualcoolingtubeshape[0],
3400 fSSDAir);
3401 endladdervirtualcoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3402 endladdervirtualcoolingtubeshape[1],
3403 fSSDAir);
3404 endladdervirtualcoolingtube[2] = new TGeoVolume("EndLadderCoolingTube3",
3405 endladdervirtualcoolingtubeshape[2],
3406 fSSDAir);
3407 endladdervirtualcoolingtube[3] = new TGeoVolume("EndLadderCoolingTube4",
3408 endladdervirtualcoolingtubeshape[3],
3409 fSSDAir);
3410 endladdervirtualcoolingtube[4] = new TGeoVolume("EndLadderCoolingTube5",
3411 endladdervirtualcoolingtubeshape[4],
3412 fSSDAir);
bf210566 3413 TList* coolingtubelist = new TList();
3414 for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3415 virtualcoolingtube[i]->AddNode(coolingtube[i][0],1);
3416 virtualcoolingtube[i]->AddNode(coolingtube[i][1],1);
3417 coolingtubelist->Add(virtualcoolingtube[i]);
d7599219 3418 }
9b0c60ab 3419 endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3420 endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3421 coolingtubelist->Add(endladdervirtualcoolingtube[0]);
3422 endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3423 endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3424 coolingtubelist->Add(endladdervirtualcoolingtube[1]);
3425 endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][0],1);
3426 endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][1],1);
3427 coolingtubelist->Add(endladdervirtualcoolingtube[2]);
3428 endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][0],1);
3429 endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][1],1);
3430 coolingtubelist->Add(endladdervirtualcoolingtube[3]);
3431 endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][0],1);
3432 endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][1],1);
3433 coolingtubelist->Add(endladdervirtualcoolingtube[4]);
bf210566 3434 return coolingtubelist;
d7599219 3435}
bf210566 3436///////////////////////////////////////////////////////////////////////////////
3437TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3438 /////////////////////////////////////////////////////////////
bf210566 3439 // Method generating SSD Cooling Block
44285dfa 3440 /////////////////////////////////////////////////////////////
bf210566 3441 const Int_t kvertexnumber = 8;
3442 ///////////////////////////////////////
3443 // Vertex Positioning for TGeoXTru
3444 ///////////////////////////////////////
3445 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3446 vertexposition[0] = new TVector3(0.0,0.0);
3447 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3448 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3449 vertexposition[1]->Y());
3450 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3451 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3452 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3453 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3454 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3455 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3456 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3457 - fgkSSDCoolingBlockHoleLength[0]
3458 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3459 fgkSSDCoolingBlockHeight[0]
3460 - fgkSSDCoolingBlockHoleRadius[1],
3461 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3462 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3463 - fgkSSDCoolingBlockHoleLength[0]),
3464 vertexposition[6]->Y());
3465 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3466 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3467 Double_t phi = 180.-alpha;
3468 Double_t psi = 180.+2.*alpha;
3469 Double_t deltapsi = psi/nedges;
3470 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3471 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3472 fgkSSDCoolingBlockHoleCenter);
3473 for(Int_t i=0; i<nedges+1; i++){
3474 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3475 radius*SinD(phi+i*deltapsi));
3476 *vertexposition[kvertexnumber+i] += (*transvector);
3477 }
3478 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3479 for(Int_t i=0; i<kvertexnumber; i++)
3480 vertexposition[kvertexnumber+nedges+1+i] =
3481 GetReflection(vertexposition[kvertexnumber-1-i],param);
3482 ///////////////////////////////////////////////////////////////////////
3483 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3484 ///////////////////////////////////////////////////////////////////////
3485 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3486 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3487 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3488 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3489 xvertexpoints[i] = vertexposition[i]->X();
3490 yvertexpoints[i] = vertexposition[i]->Y();
3491 }
3492 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3493 yvertexpoints);
3494 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3495 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3496 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3497 ssdcoolingblockshape,
3498 fSSDAlCoolBlockMedium);
3499 ssdcoolingblock->SetLineColor(fColorAl);
3500 /////////////////////////////////////////////////////////////
3501 // Deallocating memory
3502 /////////////////////////////////////////////////////////////
3503 delete [] vertexposition;
3504 delete xvertexpoints;
3505 delete yvertexpoints;
3506 /////////////////////////////////////////////////////////////
3507 return ssdcoolingblock;
3508}
3509/////////////////////////////////////////////////////////////////////////////////
3510TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
d7599219 3511 ///////////////////////////////////////////////////////
bf210566 3512 const Int_t kssdchipcablesnumber = 2;
3513 const Int_t kssdchipcableslaynumber = 2;
3514 const Int_t kvertexnumber = 4*(nedges+1)+4;
3515 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3516 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3517 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
3518 - fgkSSDChipCablesHeight[0]
3519 - fgkSSDChipCablesHeight[1]);
3520 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3521 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3522 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3523 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3524 - ssdchipcablesradius[0]
3525 - fgkSSDChipCablesWidth[1]
3526 - fgkSSDChipCablesWidth[2]);
3527 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3528 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3529 + fgkSSDChipCablesHeight[1]
3530 + fgkSSDSensorHeight);
d7599219 3531 ///////////////////////////////////////////////////////
bf210566 3532 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3533 ///////////////////////////////////////////////////////
3534 TVector3** vertexposition[kssdchipcableslaynumber];
3535 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3536 new TVector3*[4*(nedges+1)+4];
3537 Double_t ratio[4];
3538 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3539 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3540 / ssdchipcablesradius[0];
3541 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3542 / ssdchipcablesradius[0];
3543 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3544 + fgkSSDChipCablesHeight[1])
3545 / ssdchipcablesradius[0];
3546 Double_t phi = 180.;
3547 Double_t deltaphi = 180./nedges;
3548 Double_t angle = 0.0;
3549 Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3550 Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3551 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3552 xvertexpoints[i] = new Double_t[kvertexnumber];
3553 yvertexpoints[i] = new Double_t[kvertexnumber];
3554 }
3555 TVector3* vertex = new TVector3();
3556 TVector3* transvector[kssdchipcableslaynumber];
3557 transvector[0] = new TVector3(fgkSSDChipWidth,
3558 SSDChipCablesHeigth-ssdchipcablesradius[0]);
3559 transvector[1] = new TVector3();
3560 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
3561 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
3562 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
3563 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3564 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3565 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3566 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3567 transvector[1]->SetY(ssdchipcablesradius[0]
3568 + fgkSSDChipCablesHeight[0]
3569 + fgkSSDChipCablesHeight[1]);
3570 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3571 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
3572 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
3573 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
3574 - i*fgkSSDChipCablesHeight[0]);
3575 vertexposition[i][2*(nedges+1)+2] =
3576 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3577 + fgkSSDChipCablesWidth[1]
3578 + fgkSSDChipCablesWidth[2],
3579 ((1.-i)*fgkSSDChipCablesHeight[i]
3580 + fgkSSDChipCablesHeight[1]));
3581 vertexposition[i][2*(nedges+1)+3] =
3582 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3583 vertexposition[i][2*(nedges+1)+2]->Y()
3584 - fgkSSDChipCablesHeight[i]);
3585 for(Int_t j=0; j<nedges+1; j++){
3586 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3587 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3588 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3589 vertexposition[0][(nedges+1)*i+j+2] =
3590 new TVector3(*vertex+*transvector[i]);
3591 vertexposition[1][(nedges+1)*i+j+2] =
3592 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3593 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3594 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3595 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3596 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3597 new TVector3(vertex->X()*ratio[2*i+1]
3598 + transvector[i]->X(),
3599 vertex->Y()*ratio[2*i+1]
3600 + transvector[i]->Y());
3601 }
3602 }
3603 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3604 for(Int_t j=0; j<kvertexnumber; j++){
3605 xvertexpoints[i][j] = vertexposition[i][j]->X();
3606 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3607 }
3608 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3609 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3610 xvertexpoints[i],yvertexpoints[i]);
3611 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3612 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3613 ssdchipcable[kssdchipcablesnumber*k+i] =
3614 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3615 ssdchipcableshape[kssdchipcablesnumber*k+i],
3616 (kssdchipcablesnumber*k+i)%2==0?
3617 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3618 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3619 }
3620 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3621 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3622 }
44285dfa 3623 /////////////////////////////////////////////////////////////
bf210566 3624 // Mother Volume definition
3625 /////////////////////////////////////////////////////////////
3626 Double_t ssdchipseparation = fgkSSDSensorLength
3627 - 2.*fgkSSDModuleStiffenerPosition[1]
3628 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3629 - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
3630 Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth};
3631 Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0]
3632 +fgkSSDChipCablesWidth[1]
3633 +fgkSSDChipCablesWidth[2]);
3634 Double_t dy = fgkSSDChipCablesLength[1];
3635 Double_t dz = SSDChipCablesHeigth;
3636 TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
3637 TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother",
3638 ssdchipcablesmotherbox,fSSDAir);
3639 /////////////////////////////////////////////////////////////
3640 // Rotation and Translation Definition for positioning
3641 /////////////////////////////////////////////////////////////
3642 TGeoRotation* ssdchipcablesrot[5];
3643 ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
3644 ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
3645 ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
3646 ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
3647 ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
3648 TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,
3649 0.,0.,ssdchipcablesrot[2]);
3650 ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]);
3651 ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]);
3652 ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans);
3653 ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans);
3654 /////////////////////////////////////////////////////////////
3655 // Deallocating memory
3656 /////////////////////////////////////////////////////////////
3657 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3658 delete [] xvertexpoints[i];
3659 delete [] yvertexpoints[i];
3660 }
3661 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3662 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3663 delete vertex;
3664 delete ssdchipcablesrot[0];
3665 delete ssdchipcablesrot[1];
3666 delete ssdchipcablesrot[3];
3667 /////////////////////////////////////////////////////////////
3668 return ssdchipcablesmother;
d7599219 3669}
bf210566 3670///////////////////////////////////////////////////////////////////////////////
3671TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
3672 /////////////////////////////////////////////////////////////
3673 // SSD Chip Assembly
3674 /////////////////////////////////////////////////////////////
3675 TGeoVolume* ssdchipassembly = GetSSDChips();
3676 TList* ssdchipsystemlist = new TList();
3677 const Int_t knedges = 20;
3678 const Int_t kchipsystemnumber = 2;
3679 /////////////////////////////////////////////////////////////
3680 // Mother Volume containing SSDChipSystem
3681 /////////////////////////////////////////////////////////////
3682 TGeoXtru* chipsystemothershape[kchipsystemnumber];
3683 for(Int_t i=0; i<kchipsystemnumber; i++) chipsystemothershape[i] = new TGeoXtru(2);
3684 const Int_t kmothervertexnumber = 12;
3685 Double_t xmothervertex[kchipsystemnumber][kmothervertexnumber];
3686 Double_t ymothervertex[kchipsystemnumber][kmothervertexnumber];
3687 Double_t ssdchipcablesradius[kchipsystemnumber];
3688 Double_t ssdchipseparation = fgkSSDSensorLength
3689 - 2.*fgkSSDModuleStiffenerPosition[1]
3690 - 2.*(fgkSSDStiffenerWidth
3691 - fgkSSDStiffenerToChipDist-0.5*fgkSSDChipWidth);
3692 for(Int_t i=0; i<kchipsystemnumber; i++)
3693 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
3694 - fgkSSDChipCablesHeight[0]
3695 - fgkSSDChipCablesHeight[1]);
3696 ///////////////////////
3697 // Setting the vertices
3698 ///////////////////////
3699 xmothervertex[0][0] = -0.5*fgkSSDChipCablesLength[1];
3700 xmothervertex[0][1] = xmothervertex[0][0];
3701 xmothervertex[0][2] = (fgkSSDChipNumber-1)*(fgkSSDChipLength
3702 + fgkSSDChipSeparationLength)+0.5*fgkSSDChipCablesLength[1];
3703 xmothervertex[0][3] = xmothervertex[0][2];
3704 xmothervertex[0][4] = 0.5*fgkSSDChipCablesLength[1];
3705 xmothervertex[0][5] = xmothervertex[0][4];
3706 xmothervertex[0][6] = xmothervertex[0][2]-0.5*fgkSSDChipCablesLength[1];
3707 xmothervertex[0][7] = xmothervertex[0][6];
3708 xmothervertex[0][8] = 0.0;
3709 xmothervertex[0][9] = xmothervertex[0][8];
3710 xmothervertex[0][10] = xmothervertex[0][4];
3711 xmothervertex[0][11] = xmothervertex[0][10];
3712 for(Int_t i=0; i<kmothervertexnumber; i++)
3713 xmothervertex[1][i] = xmothervertex[0][i];
3714 for(Int_t i=0; i<kchipsystemnumber; i++){
3715 ymothervertex[i][0] = -0.5*fgkSSDChipWidth-ssdchipcablesradius[i]
3716 - fgkSSDChipCablesWidth[1]-fgkSSDChipCablesWidth[2];
3717 ymothervertex[i][1] = ssdchipseparation-ymothervertex[i][0];
3718 ymothervertex[i][2] = ymothervertex[i][1];
3719 ymothervertex[i][3] = ymothervertex[i][0];
3720 ymothervertex[i][4] = ymothervertex[i][0];
3721 ymothervertex[i][5] = 0.5*fgkSSDChipWidth;
3722 ymothervertex[i][6] = ymothervertex[i][5];
3723 ymothervertex[i][7] = ssdchipseparation-0.5*fgkSSDChipWidth;
3724 ymothervertex[i][8] = ymothervertex[i][7];
3725 ymothervertex[i][9] = ymothervertex[i][5];
3726 ymothervertex[i][10] = ymothervertex[i][5];
3727 ymothervertex[i][11] = ymothervertex[i][4];
3728 }
3729 //////////////////////////////////////////////////////////
3730 TGeoVolume* chipsystemother[kchipsystemnumber];
3731 const char* chipsytemothername[kchipsystemnumber] =
3732 {"SSDChipSytemother1","SSDChipSytemother2"};
3733 for(Int_t i=0; i<kchipsystemnumber; i++){
3734 chipsystemothershape[i]->DefinePolygon(kmothervertexnumber,
3735 xmothervertex[i],ymothervertex[i]);
3736 chipsystemothershape[i]->DefineSection(0,-fgkSSDChipCablesHeight[i+2]
3737 -0.5*fgkSSDChipHeight);
3738 chipsystemothershape[i]->DefineSection(1,0.5*fgkSSDChipHeight);
3739 chipsystemother[i] = new TGeoVolume(chipsytemothername[i],
3740 chipsystemothershape[i],fSSDAir);
3741 }
44285dfa 3742 /////////////////////////////////////////////////////////////
bf210566 3743 // SSD Chip Cables
3744 /////////////////////////////////////////////////////////////
3745 TGeoVolume* ssdchipcables[kchipsystemnumber];
3746 TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
3747 TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
3748 TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
3749 //////////////////
3750 for(Int_t i=0; i<kchipsystemnumber; i++){
3751 ssdchipcables[i] =
3752 GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
3753 ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
3754 ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
3755 ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
3756 }
3757 for(Int_t i=0; i<kchipsystemnumber; i++){
3758 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3759 ssdchipcablestrans[i][j] = new TGeoTranslation();
3760 ssdchipcablesrot[i][j] = new TGeoRotation();
3761 ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
3762 ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
3763 ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
3764 + fgkSSDChipSeparationLength),
3765 0.5*fgkSSDChipWidth,
3766 - 0.5*fgkSSDChipHeight
3767 - fgkSSDChipCablesHeight[i+2]);
3768 ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
3769 ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
3770 chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
3771
3772 }
3773 chipsystemother[i]->AddNode(ssdchipassembly,i+1);
3774 ssdchipsystemlist->Add(chipsystemother[i]);
3775 }
3776 /////////////////////////////////////////////////////////////
3777 // Deallocating memory
3778 /////////////////////////////////////////////////////////////
3779 for(Int_t i=0; i<kchipsystemnumber; i++){
3780 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3781 delete ssdchipcablesrot[i][j];
3782 delete ssdchipcablestrans[i][j];
3783 }
3784 delete ssdchipcablesrot[i];
3785 delete ssdchipcablestrans[i];
3786 }
3787 /////////////////////////////////////////////////////////////
3788 return ssdchipsystemlist;
d7599219 3789}
bf210566 3790///////////////////////////////////////////////////////////////////////////////
3791TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
44285dfa 3792 /////////////////////////////////////////////////////////////
bf210566 3793 // SSD Chip Assembly Generation
3794 /////////////////////////////////////////////////////////////
3795 const Int_t kssdchiprownumber = 2;
3796 TGeoBBox* ssdchipcompshape[2];
3797 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3798 0.5*fgkSSDChipLength,
3799 0.5*fgkSSDChipWidth,
3800 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3801 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3802 0.5*fgkSSDChipLength,
3803 0.5*fgkSSDChipWidth,
3804 0.5*fgkSSDChipGlueHeight);
3805 TGeoVolume* ssdchipcomp[2];
3806 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3807 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3808 fSSDChipGlueMedium);
3809 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3810 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3811 TGeoTranslation* ssdchipcomptrans[2];
3812 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3813 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3814 /////////////////////////////////////////////////////////////
3815 // Virtual Volume containing SSDChip
3816 /////////////////////////////////////////////////////////////
3817 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3818 0.5*fgkSSDChipWidth,
3819 0.5*fgkSSDChipHeight);
3820 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
3821 /////////////////////////////////////////////////////////////
3822 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3823 Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
3824 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3825 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3826 - 0.5*fgkSSDChipWidth)};
3827 /////////////////////////////////////////////////////////////
3828 // Virtual Volume containing SSDChipAssembly
3829 /////////////////////////////////////////////////////////////
3830 TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
3831 const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
3832 Double_t xmothervertex[kssdmothervertexnumber];
3833 Double_t ymothervertex[kssdmothervertexnumber];
3834 ///////////////////////
3835 // Setting the vertices
3836 ///////////////////////
3837 xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
3838 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
3839 - ymothervertex[0];
3840 xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
3841 ymothervertex[2] = ymothervertex[1];
3842 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
3843 xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
3844 ymothervertex[4] = ymothervertex[0];
3845 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
3846 xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
3847 + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
3848 ymothervertex[6] = ymothervertex[5];
3849 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
3850 - fgkSSDChipWidth;
3851 xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3852 ymothervertex[8] = ymothervertex[7];
3853 xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3854 ymothervertex[9] = ymothervertex[6];
3855 xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
3856 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
3857 //////////////////////////////////////////////////////////
3858 ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
3859 xmothervertex,ymothervertex);
3860 ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
3861 ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
3862 TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
3863 ssdchipmothershape,fSSDAir);
3864 /////////////////////////////////////////////////////////////
3865 for(Int_t i=0; i<kssdchiprownumber; i++)
3866 for(Int_t j=0; j<fgkSSDChipNumber; j++)
3867 ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
3868 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
3869 return ssdchipmother;
d7599219 3870}
bf210566 3871/////////////////////////////////////////////////////////////////////////////////
3872TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3873 /////////////////////////////////////////////////////////////
bf210566 3874 // Method returning a List containing pointers to Ladder Cable Volumes
44285dfa 3875 /////////////////////////////////////////////////////////////
bf210566 3876 const Int_t kladdercablesegmentnumber = 2;
3877 /////////////////////////////////////////
3878 // LadderSegmentBBox Volume
3879 /////////////////////////////////////////
3880 TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
3881 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3882 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3883 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3884 new TGeoBBox(laddercablesegmentbboxshapename[i],
3885 0.5*fgkSSDFlexWidth[0],
3886 0.5*fgkSSDLadderCableWidth,
3887 0.5*fgkSSDFlexHeight[i]);
3888 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3889 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3890 TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3891 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3892 laddercablesegmentbbox[i] =
3893 new TGeoVolume(laddercablesegmentbboxname[i],
3894 laddercablesegmentbboxshape[i],
3895 (i==0?fSSDAlTraceLadderCableMedium:
3896 fSSDKaptonLadderCableMedium));
3897 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3898 fColorPolyhamide);
3899 }
3900 TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
3901 laddercablesegmentbboxtrans[0] =
3902 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3903 0.5*fgkSSDFlexWidth[0],
3904 0.5*fgkSSDLadderCableWidth,
3905 0.5*fgkSSDFlexHeight[0]);
3906 laddercablesegmentbboxtrans[1] =
3907 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3908 0.5*fgkSSDFlexWidth[0],
3909 0.5*fgkSSDLadderCableWidth,
3910 fgkSSDFlexHeight[0]
3911 +0.5*fgkSSDFlexHeight[1]);
3912 TGeoVolume* laddercablesegmentbboxassembly =
3913 new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
3914 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3915 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3916 laddercablesegmentbboxtrans[i]);
3917/////////////////////////////////////////
3918// LadderSegmentArb8 Volume
3919/////////////////////////////////////////
3920 const Int_t kvertexnumber = 4;
3921 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3922 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3923 new TVector3*[kvertexnumber];
3924//Shape Vertex Positioning
3925 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3926 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3927 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3928 i*fgkSSDFlexHeight[0]);
3929 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3930 + fgkSSDFlexHeight[1]
3931 + i*fgkSSDFlexHeight[0]);
3932 laddercablesegmentvertexposition[i][3] =
3933 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3934 laddercablesegmentvertexposition[i][2]->Y());
3935 }
3936 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3937 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3938 char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3939 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3940 TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3941 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3942 GetArbShape(laddercablesegmentvertexposition[i],
3943 laddercablesegmentwidth[i],
3944 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3945 laddercablesegmentarbshapename[i]);
3946 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3947 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3948 TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3949 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3950 laddercablesegmentarb[i] =
3951 new TGeoVolume(laddercablesegmentarbname[i],
3952 laddercablesegmentarbshape[i],
3953 (i==0?fSSDAlTraceLadderCableMedium:
3954 fSSDKaptonLadderCableMedium));
3955 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3956 fColorPolyhamide);
d7599219 3957}
bf210566 3958 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3959 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3960 90.,90,-90.);
3961 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3962 0.,90.,0.);
3963 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3964 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3965 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3966 + fgkSSDFlexWidth[0],0.,0.,
3967 new TGeoRotation((*laddercablesegmentarbrot[1])
3968 *(*laddercablesegmentarbrot[0])));
3969 TGeoVolume* laddercablesegmentarbassembly =
3970 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3971 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3972 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3973 laddercablesegmentarbcombitrans);
3974/////////////////////////////////////////
3975// End Ladder Cable Volume
3976/////////////////////////////////////////
3977 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3978 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3979 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3980 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3981 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3982 0.5*ssdendladdercablelength,
3983 0.5*fgkSSDLadderCableWidth,
3984 0.5*fgkSSDFlexHeight[i]);
3985 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3986 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3987 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3988 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3989 ladderendcablesegmentbbox[i] =
3990 new TGeoVolume(ladderendcablesegmentbboxname[i],
3991 ladderendcablesegmentbboxshape[i],
3992 (i==0?fSSDAlTraceLadderCableMedium:
3993 fSSDKaptonLadderCableMedium));
3994 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3995 fColorPolyhamide);
3996 }
3997 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3998 ladderendcablesegmentbboxtrans[0] =
3999 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
4000 0.5*ssdendladdercablelength,
4001 0.5*fgkSSDLadderCableWidth,
4002 0.5*fgkSSDFlexHeight[0]);
4003 ladderendcablesegmentbboxtrans[1] =
4004 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
4005 0.5*ssdendladdercablelength,
4006 0.5*fgkSSDLadderCableWidth,
4007 fgkSSDFlexHeight[0]
4008 +0.5*fgkSSDFlexHeight[1]);
4009 TGeoVolume* ladderendcablesegmentbboxassembly =
4010 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
4011 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
4012 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
4013 ladderendcablesegmentbboxtrans[i]);
4014/////////////////////////////////////////
4015 TList* laddercablesegmentlist = new TList();
4016 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
4017 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
4018 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
4019 return laddercablesegmentlist;
4020 }
4021/////////////////////////////////////////////////////////////////////////////////
4022TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 4023 /////////////////////////////////////////////////////////////
bf210566 4024 // Method generating Ladder Cable Volumes Assemblies
44285dfa 4025 /////////////////////////////////////////////////////////////
bf210566 4026 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
4027 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
4028 for(Int_t i=0; i<n; i++){
4029 TGeoTranslation* laddercabletrans = new TGeoTranslation(
4030 i*(fgkCarbonFiberJunctionWidth),
4031 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4032 i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4033 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
4034 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
d7599219 4035 }
bf210566 4036 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
4037 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4038 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4039 (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4040 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
4041 return laddercable;
4042}
4043/////////////////////////////////////////////////////////////////////////////////
4044TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
4045 /////////////////////////////////////////////////////////////
4046 // Method generating Ladder Cable Volumes Assembly
4047 /////////////////////////////////////////////////////////////
4048 TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
4049 char laddercabletransname[30];
4050 for(Int_t i=0; i<n; i++){
4051 sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
4052 laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
4053 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
d7599219 4054 }
bf210566 4055 return laddercableassembly;
4056}
4057/////////////////////////////////////////////////////////////////////////////////
4058TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
4059 /////////////////////////////////////////////////////////////
4060 // Method generating Ladder Cable List Assemblies
4061 /////////////////////////////////////////////////////////////
4062 const Int_t kladdercableassemblynumber = 2;
4063 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
4064 TGeoVolume* ladderCable[kladdercableassemblynumber];
4065 char laddercableassemblyname[30];
4066 TList* laddercableassemblylist = new TList();
4067 for(Int_t i=0; i<kladdercableassemblynumber; i++){
4068 sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
4069 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
4070 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
4071 new TGeoCombiTrans((n-1)
4072 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4073 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
4074 0.,new TGeoRotation("",180,0.,0.)));
4075 laddercableassemblylist->Add(ladderCable[i]);
4076}
4077 return laddercableassemblylist;
4078}
4079///////////////////////////////////////////////////////////////////////////////
4080void AliITSv11GeometrySSD::SetLadderSegment(){
4081 /////////////////////////////////////////////////////////////
4082 // Method Generating Ladder Segment Array
4083 /////////////////////////////////////////////////////////////
4084 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
4085 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
4086 if(!fCreateMaterials) CreateMaterials();
4087 if(!fTransformationMatrices) CreateTransformationMatrices();
4088 if(!fBasicObjects) CreateBasicObjects();
4089 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
4090 // Placing Carbon Fiber Support
4091 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
4092 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4093 fcarbonfibersupportmatrix[j]);
4094 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4095 fcarbonfibersupportmatrix[j]);
d7599219 4096 }
bf210566 4097 // Placing Carbon Fiber Junction
4098 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
4099 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
4100 fcarbonfiberjunctionmatrix[j]);
4101 // Placing Carbon Fiber Lower Support
4102 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++)
4103 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
4104 fcarbonfiberlowersupportrans[j]);
4105 // Placing SSD Sensor Support
4106 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
4107 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
4108 fssdsensorsupport[1][i],
4109 j+1,fssdsensorsupportmatrix[j]);
4110 // Placing SSD Cooling Tube Support
4111 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
4112 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4113 fcoolingtubesupportmatrix[j]);
4114 // Placing SSD Cooling Tube
4115 for(Int_t j=0; j<2; j++)
4116 for(Int_t k=0; k<2; k++){
4117 fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]);
4118 fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]);
4119 }
4120 // Placing SSD Hybrid
4121 switch(i){
4122 case 0:
4123 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
4124 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4125 break;
4126 case 1:
4127 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
4128 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4129 break;
4130 }
4131 // Placing Cooling Block System
4132 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
4133 // Placing SSD Flex
4134 for(Int_t j=0; j<fgkflexnumber; j++){
4135 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
4136 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
4137 }
4138 }
d7599219 4139}
bf210566 4140///////////////////////////////////////////////////////////////////////////////
4141void AliITSv11GeometrySSD::SetEndLadderSegment(){
4142 /////////////////////////////////////////////////////////////
4143 // Method Generating End Ladder
4144 /////////////////////////////////////////////////////////////
4145 // End Ladder Carbon Fiber Junction
4146 /////////////////////////////////////////////////////////////
4147 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
4148 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
4149 if(!fCreateMaterials) CreateMaterials();
4150 if(!fTransformationMatrices) CreateTransformationMatrices();
4151 if(!fBasicObjects) CreateBasicObjects();
4152 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
4153 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
4154 fendladdersegment[i]->AddNode(j==2 ?
4155 fendladdercarbonfiberjunction[i][1] :
4156 fendladdercarbonfiberjunction[i][0],
4157 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
4158 }
4159 /////////////////////////////////////////////////////////////
4160 // End Ladder Carbon Fiber Support
4161 /////////////////////////////////////////////////////////////
4162 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
4163 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
4164 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4165 fendladdercarbonfibermatrix[i][j]);
4166 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4167 fendladdercarbonfibermatrix[i][j]);
4168 }
4169 /////////////////////////////////////////////////////////////
4170 // End Ladder Mounting Block
4171 /////////////////////////////////////////////////////////////
9b0c60ab 4172 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4173 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
4174 fendladdermountingblockcombitrans[i]);
4175 /////////////////////////////////////////////////////////////
4176 // End Ladder Mounting Block
4177 /////////////////////////////////////////////////////////////
4178 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4179 for(Int_t j=0; j<2; j++)
4180 fendladdersegment[i]->AddNode(fendladdermountingblockclip,i+1,
4181 fendladdermountingblockclipmatrix[i][j]);
bf210566 4182 /////////////////////////////////////////////////////////////
4183 // End Ladder Lower Supports
44285dfa 4184 /////////////////////////////////////////////////////////////
bf210566 4185 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
4186 fendladderlowersupptrans[0]);
4187 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
4188 fendladderlowersupptrans[1]);
4189 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
4190 fendladderlowersupptrans[2]);
9b0c60ab 4191 /////////////////////////////////////////////////////////////
4192 // End Ladder Cooling Tube Support
4193 /////////////////////////////////////////////////////////////
4194 for(Int_t i=0; i<2; i++)
4195 for(Int_t j=0; j<(i==0?4:2); j++)
4196 fendladdersegment[i]->AddNode(fcoolingtubesupport,
4197 j+1,fendladdercoolingtubesupportmatrix[i][j]);
4198 /////////////////////////////////////////////////////////////
4199 // End Ladder Cooling Tube Support
4200 /////////////////////////////////////////////////////////////
4201 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
4202 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
4203 fendladdersegment[0]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[0][2]);
4204 fendladdersegment[0]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[0][3]);
4205 fendladdersegment[0]->AddNode(fendladdercoolingtube[2],1,fendladdercoolingtubematrix[0][4]);
4206 fendladdersegment[0]->AddNode(fendladdercoolingtube[2],2,fendladdercoolingtubematrix[0][5]);
4207 fendladdersegment[1]->AddNode(fendladdercoolingtube[3],1,fendladdercoolingtubematrix[1][0]);
4208 fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);
4209 fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);
4210 fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);
4211 fendladdersegment[0]->CheckOverlaps(0.01);
4212 fendladdersegment[1]->CheckOverlaps(0.01);
bf210566 4213}
4214///////////////////////////////////////////////////////////////////////////////
4215void AliITSv11GeometrySSD::SetLadder(){
4216 /////////////////////////////////////////////////////////////
4217 // Method Generating Ladder of Layer 5 and 6
44285dfa 4218 /////////////////////////////////////////////////////////////
bf210566 4219 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
4220 fgkSSDLay6SensorsNumber};
4221 /////////////////////////////////////////////////////////////////////////////
4222 /// Generating Ladder Mother Volume Containing Ladder
4223 /////////////////////////////////////////////////////////////////////////////
4224 TGeoXtru* laddershape[fgkladdernumber];
4225 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
4226 const Int_t kmothervertexnumber = 8;
4227 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
4228 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
4229 ///////////////////////
4230 // Setting the vertices
4231 ///////////////////////
4232 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
4233 * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
4234 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
4235 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
4236 xmothervertex[0][1] = xmothervertex[0][0];
4237 ymothervertex[0][1] = 0.0;
4238 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
4239 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
4240 ymothervertex[0][2] = ymothervertex[0][1];
4241 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
4242 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
4243 xmothervertex[0][4] = -xmothervertex[0][3];
4244 ymothervertex[0][4] = ymothervertex[0][3];
4245 xmothervertex[0][5] = -xmothervertex[0][2];
4246 ymothervertex[0][5] = ymothervertex[0][2];
4247 xmothervertex[0][6] = -xmothervertex[0][1];
4248 ymothervertex[0][6] = ymothervertex[0][1];
4249 xmothervertex[0][7] = -xmothervertex[0][0];
4250 ymothervertex[0][7] = ymothervertex[0][0];
4251 for(Int_t i=0; i<kmothervertexnumber; i++){
4252 xmothervertex[1][i] = xmothervertex[0][i];
4253 ymothervertex[1][i] = ymothervertex[0][i];
4254 }
4255 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4256 for(Int_t i=0; i<fgkladdernumber; i++){
4257 laddershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
4258 ymothervertex[i]);
4259 laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4260 laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4261 +fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4262 fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir);
9b0c60ab 4263 fladder[i]->SetLineColor(4);
bf210566 4264 }
4265///////////////////////////////////////////////////////////////////////////
4266 if(!fCreateMaterials) CreateMaterials();
4267 if(!fTransformationMatrices) CreateTransformationMatrices();
4268 if(!fBasicObjects) CreateBasicObjects();
4269 SetLadderSegment();
4270 SetEndLadderSegment();
4271 for(Int_t i=0; i<fgkladdernumber; i++){
4272 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4273 //////////////////////////
4274 /// Placing Ladder Segment
4275 //////////////////////////
4276 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4277 fladdersegment[i==0 ? 1 : 0],
4278 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4279 //////////////////////////
4280 /// Placing SSD Sensor
4281 //////////////////////////
4282 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4283 fssdsensormatrix[i][j]);
4284 }
4285 ///////////////////////////////
4286 /// Placing End Ladder Segment
4287 ///////////////////////////////
4288 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4289 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4290 }
d7599219 4291/////////////////////////////////////////////////////////////////////////////
4292/// Placing Ladder Cables
4293/////////////////////////////////////////////////////////////////////////////
bf210566 4294 Int_t sidecablenumber[2][2];
4295 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4296 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4297 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4298 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4299 Double_t carbonfibertomoduleposition[3];
4300 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4301 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4302 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4303 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4304 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4305 - fgkSSDSensorCenterSupportThickness[0]);
4306 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4307 + 0.5*fgkCoolingTubeSupportHeight
4308 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4309 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4310 Double_t ssdendladdercablelength[4];
4311 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4312 + fgkSSDSensorLength
4313 - fgkSSDModuleStiffenerPosition[1]
4314 - fgkSSDStiffenerWidth
4315 - fgkSSDFlexWidth[0]
bf210566 4316 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4317 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4318 + fgkSSDModuleStiffenerPosition[1]
4319 + fgkSSDStiffenerWidth
bf210566 4320 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4321 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4322 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4323 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4324 - kendladdercablecorrection;
44285dfa 4325 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4326 + carbonfibertomoduleposition[1]
d7599219 4327 - fgkSSDModuleStiffenerPosition[1]
4328 - fgkSSDStiffenerWidth)
bf210566 4329 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
44285dfa 4330 TList* laddercableassemblylist[4];
4331 const Int_t kendladdercablesnumber = 4;
bf210566 4332 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4333 for(Int_t j=0; j<kendladdercablesnumber; j++){
4334 laddercableassemblylist[j] =
4335 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4336 ssdendladdercablelength[j]);
4337 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4338 j<2?1:2,fladdercablematrix[i][j]);
4339 }
9b0c60ab 4340// fladder[0]->CheckOverlaps(0.01);
4341// fladder[1]->CheckOverlaps(0.01);
bf210566 4342}
4343////////////////////////////////////////////////////////////////////////////////
4344void AliITSv11GeometrySSD::SetLayer(){
d7599219 4345////////////////////////////////////////////////////////////////////////////////
bf210566 4346 // Creating Ladder of Layer 5 and Layer 6
4347 /////////////////////////////////////////////////////////////
4348 if(!fCreateMaterials) CreateMaterials();
4349 if(!fTransformationMatrices) CreateTransformationMatrices();
4350 if(!fBasicObjects) CreateBasicObjects();
4351 SetLadder(); // Generating the ladder of Layer5 and Layer6
4352 const Int_t kssdlayladdernumber[fgklayernumber] =
4353 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4354 /////////////////////////////////////////////////////////////
4355 // Generating mother volumes for Layer5 and Layer6
4356 /////////////////////////////////////////////////////////////
4357 TGeoXtru* ssdladdermothershape = (TGeoXtru*)fladder[0]->GetShape();
9b0c60ab 4358 TGeoXtru* layercontainershape[fgklayernumber];
4359 for(Int_t i=0; i<fgklayernumber; i++) layercontainershape[i] = new TGeoXtru(2);
4360 const Int_t kladdercontainernumber = 8;
4361 TVector3* laddercontainervertex[kladdercontainernumber];
4362 for(Int_t i=0; i<kladdercontainernumber; i++) laddercontainervertex[i] =
4363 new TVector3(ssdladdermothershape->GetX(i),
4364 ssdladdermothershape->GetY(i)-ssdladdermothershape->GetY(0));
4365 TVector3** transvector[fgklayernumber];
4366 Double_t layerradius = 0.;
4367 Double_t layerladderangleposition[fgklayernumber] =
4368 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
4369 Double_t** rotationangle = new Double_t*[fgklayernumber];
4370 for(Int_t i=0; i<fgklayernumber; i++) rotationangle[i] =
4371 new Double_t[kssdlayladdernumber[i]];
4372 for(Int_t i=0; i<fgklayernumber; i++) transvector[i] = new TVector3*[kssdlayladdernumber[i]];
4373 for(Int_t i=0; i<fgklayernumber; i++)
4374 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4375 switch(i){
4376 case 0: //Ladder of Layer5
4377 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
4378 break;
4379 case 1: //Ladder of Layer6
4380 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
4381 break;
4382 }
4383 transvector[i][j] = new TVector3(layerradius*CosD(90.0+j*layerladderangleposition[i]),
4384 layerradius*SinD(90.0+j*layerladderangleposition[i]));
4385 rotationangle[i][j] = j*layerladderangleposition[i]*TMath::DegToRad();
4386 }
4387 TVector3** layercontainervertex[fgklayernumber];
4388 for(Int_t i=0; i<fgklayernumber; i++) layercontainervertex[i] =
4389 new TVector3*[5*(1+kssdlayladdernumber[i])];
4390 Int_t uplayerindex[2] = {0,7};
4391 Int_t downlayerindex[4] = {1,0,7,6};
4392 for(Int_t i=0; i<fgklayernumber; i++){
4393 Int_t vertexindex = 0;
4394 layercontainervertex[i][0] = new TVector3(0.,laddercontainervertex[0]->Y());
4395 layercontainervertex[i][1] = new TVector3(0.,laddercontainervertex[3]->Y());
4396 layercontainervertex[i][2] = new TVector3(*laddercontainervertex[3]);
4397 for(Int_t j=0; j<3; j++){
4398 layercontainervertex[i][j]->RotateZ(rotationangle[i][0]);
4399 *layercontainervertex[i][j] += *transvector[i][0];
4400 vertexindex++;
4401 }
4402 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4403 for(Int_t l=0; l<2; l++){
4404 layercontainervertex[i][vertexindex] = new TVector3(l==0?
4405 * laddercontainervertex[4]:
4406 * laddercontainervertex[3]);
4407 layercontainervertex[i][vertexindex]->RotateZ(rotationangle[i][j]);
4408 *layercontainervertex[i][vertexindex] += *transvector[i][j];
4409 vertexindex++;
4410 }
4411 }
4412 layercontainervertex[i][vertexindex] = new TVector3(*laddercontainervertex[4]);
4413 layercontainervertex[i][vertexindex]->RotateZ(rotationangle[i][0]);
4414 *layercontainervertex[i][vertexindex]+= *transvector[i][0];
4415 layercontainervertex[i][vertexindex+1] = new TVector3(*layercontainervertex[i][1]);
4416 layercontainervertex[i][vertexindex+2] = new TVector3(*layercontainervertex[i][0]);
4417 vertexindex+=3;
4418 for(Int_t j=0; j<2; j++){
4419 layercontainervertex[i][vertexindex] = new TVector3(*laddercontainervertex[7-j]);
4420 layercontainervertex[i][vertexindex]->RotateZ(rotationangle[i][0]);
4421 *layercontainervertex[i][vertexindex] += *transvector[i][0];
4422 vertexindex++;
4423 }
4424 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4425 if(j%2!=0){
4426 for(Int_t l=0; l<2; l++){
4427 layercontainervertex[i][vertexindex] = new TVector3(*laddercontainervertex[uplayerindex[l]]);
4428 layercontainervertex[i][vertexindex]->RotateZ(rotationangle[i][kssdlayladdernumber[i]-j]);
4429 *layercontainervertex[i][vertexindex] += *transvector[i][kssdlayladdernumber[i]-j];
4430 vertexindex++;
4431 }
4432 }
4433 else{
4434 for(Int_t l=0; l<4; l++){
4435 layercontainervertex[i][vertexindex] =
4436 new TVector3(*laddercontainervertex[downlayerindex[l]]);
4437 layercontainervertex[i][vertexindex]->RotateZ(rotationangle[i][kssdlayladdernumber[i]-j]);
4438 *layercontainervertex[i][vertexindex] += *transvector[i][kssdlayladdernumber[i]-j];
4439 vertexindex++;
4440 }
4441 }
4442 }
4443 layercontainervertex[i][vertexindex] =
4444 new TVector3(*laddercontainervertex[1]);
4445 layercontainervertex[i][vertexindex+1] =
4446 new TVector3(*laddercontainervertex[0]);
4447 for(Int_t j=0; j<2; j++){
4448 layercontainervertex[i][vertexindex+j]->RotateZ(rotationangle[i][0]);
4449 *layercontainervertex[i][vertexindex+j] += *transvector[i][0];
4450 }
4451 layercontainervertex[i][vertexindex+2] =
4452 new TVector3(*layercontainervertex[i][0]);
4453 }
4454 Double_t** xlayervertex = new Double_t*[fgklayernumber];
4455 Double_t** ylayervertex = new Double_t*[fgklayernumber];
4456 for(Int_t i=0; i<fgklayernumber; i++){
4457 xlayervertex[i] = new Double_t[5*(1+kssdlayladdernumber[i])];
4458 ylayervertex[i] = new Double_t[5*(1+kssdlayladdernumber[i])];
4459 }
4460 for(Int_t i=0; i<fgklayernumber; i++)
4461 for(Int_t j=0; j<5*(1+kssdlayladdernumber[i]); j++){
4462 xlayervertex[i][j] = layercontainervertex[i][j]->X();
4463 ylayervertex[i][j] = layercontainervertex[i][j]->Y();
4464 }
4465 for(Int_t i=0; i<fgklayernumber; i++){
4466 layercontainershape[i]->DefinePolygon(5*(1+kssdlayladdernumber[i]),xlayervertex[i],ylayervertex[i]);
4467 layercontainershape[i]->DefineSection(0,-0.5*(i==0?fgkSSDLay5LadderLength:fgkSSDLay6LadderLength));
4468 layercontainershape[i]->DefineSection(1,0.5*(i==0?fgkSSDLay5LadderLength:fgkSSDLay6LadderLength));
4469 }
4470 fSSDLayer5 = new TGeoVolume("ITSssdLayer5",layercontainershape[0],fSSDAir);
4471 fSSDLayer6 = new TGeoVolume("ITSssdLayer6",layercontainershape[1],fSSDAir);
bf210566 4472 Int_t *ladderindex[fgklayernumber];
4473 Int_t index[fgklayernumber] = {8,9};
4474 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4475 for(Int_t i=0; i<fgklayernumber; i++)
4476 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4477 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4478 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4479 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4480 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4481 }
44285dfa 4482 /////////////////////////////////////////////////////////////
bf210566 4483 // Deallocating memory
4484 /////////////////////////////////////////////////////////////
9b0c60ab 4485 for(Int_t i=0; i<kladdercontainernumber; i++) delete laddercontainervertex[i];
4486 for(Int_t i=0; i<fgklayernumber; i++){
4487 for(Int_t j=0; j<kssdlayladdernumber[i]; j++) delete transvector[i][j];
4488 delete [] transvector[i];
4489 }
4490 for(Int_t i=0; i<fgklayernumber; i++){
4491 delete [] rotationangle[i];
4492 }
4493 delete rotationangle;
4494 for(Int_t i=0; i<fgklayernumber; i++){
4495 for(Int_t j=0; j<5*(1+kssdlayladdernumber[i]); j++)
4496 delete layercontainervertex[i][j];
4497 delete [] layercontainervertex[i];
4498 }
4499 for(Int_t i=0; i<fgklayernumber; i++){
4500 delete [] xlayervertex[i];
4501 delete [] ylayervertex[i];
4502 }
4503 delete xlayervertex;
4504 delete ylayervertex;
4505 for(Int_t i=0; i<fgklayernumber; i++) delete ladderindex[i];
d7599219 4506}
4507////////////////////////////////////////////////////////////////////////////////
4508void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4509 /////////////////////////////////////////////////////////////
4510 // Insert the layer 5 in the mother volume.
4511 /////////////////////////////////////////////////////////////
4512 if (! moth) {
4513 printf("Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!\n");
4514 return;
4515 };
bf210566 4516 if(!fSSDLayer5) SetLayer();
4517 fMotherVol = moth;
4518 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4519 + fgkLay5CenterITSPosition);
4520 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4521 }
d7599219 4522////////////////////////////////////////////////////////////////////////////////
4523void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4524 /////////////////////////////////////////////////////////////
4525 // Insert the layer 6 in the mother volume.
4526 /////////////////////////////////////////////////////////////
4527 if (! moth) {
4528 printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4529 return;
4530 };
bf210566 4531 if(!fSSDLayer6) SetLayer();
4532 fMotherVol = moth;
4533 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4534 + fgkLay6CenterITSPosition);
4535 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4536 }
bf210566 4537 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4538 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4539 /////////////////////////////////////////////////////////////
4540 // Method generating the Arc structure of Ladder Support
4541 /////////////////////////////////////////////////////////////
4542 const Int_t kssdlayladdernumber[fgklayernumber] =
4543 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4544 Double_t mountingsupportedge[fgklayernumber];
4545 Double_t mountingblockratio[fgklayernumber];
4546 Double_t theta[fgklayernumber];
4547 Double_t phi[fgklayernumber];
4548 Double_t psi0[fgklayernumber];
4549 Double_t deltapsi[fgklayernumber];
4550 TVector3* mountingsupportedgevector[fgklayernumber];
4551 for(Int_t i=0; i<fgklayernumber; i++){
4552 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4553 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4554 *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4555 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4556 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4557 / kssdlayladdernumber[i])));
4558 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4559 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4560 mountingsupportedgevector[i] = new TVector3();
4561 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4562 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(1.
4563 -TMath::Power(mountingsupportedgevector[i]->X()
4564 / fgkMountingBlockSupportRadius[i],2)));
4565 psi0[i] = 0.5*TMath::Pi()-phi[i];
4566 deltapsi[i] = (theta[i]+phi[i])/nedges;
4567 }
4568 TVector3** vertex[fgklayernumber];
4569 TList* vertexlist[fgklayernumber];
4570 Int_t indexedge[fgklayernumber] = {0,0};
4571 for(Int_t i=0; i<fgklayernumber; i++){
4572 vertex[i] = new TVector3*[nedges+1];
4573 vertexlist[i] = new TList();
4574 }
4575 for(Int_t i=0; i<fgklayernumber; i++){
4576 for(Int_t j=0; j<nedges+1; j++){
4577 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4578 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4579 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4580 vertexlist[i]->Add(vertex[i][j]);
4581 }
4582 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4583 }
4584 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4585 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4586 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4587 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4588 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4589 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4590 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4591 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4592 for(Int_t i=0; i<fgklayernumber; i++){
4593 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4594 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4595 xcentervertex[i] = new Double_t[indexedge[i]+3];
4596 ycentervertex[i] = new Double_t[indexedge[i]+3];
4597 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4598 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4599 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4600 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4601 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4602 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4603 ((TVector3*)vertexlist[i]->At(j))->X();
4604 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4605 ((TVector3*)vertexlist[i]->At(j))->Y();
4606 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4607 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4608 if(j<indexedge[i]+1){
4609 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4610 ((TVector3*)vertexlist[i]->At(j))->X();
4611 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4612 ((TVector3*)vertexlist[i]->At(j))->Y();
4613 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4614 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4615 }
4616 }
4617 xsidevertex[i][1] = xsidevertex[i][0];
4618 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4619 xsidevertex[i][2] = xsidevertex[i][3];
4620 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4621 xcentervertex[i][1] = xcentervertex[i][0];
4622 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4623 xcentervertex[i][2] = xcentervertex[i][3];
4624 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4625 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4626 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4627 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4628 ycenterlowervertex[i][0] = ysidevertex[i][0];
4629 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4630 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4631 }
4632 /////////////////////////////////////////////////////////////
4633 // Building the Arc Structure of Ladder Supports
4634 /////////////////////////////////////////////////////////////
4635 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4636 TGeoXtru* centermountingsupportshape[fgklayernumber];
4637 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4638 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4639 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4640 TGeoVolume* centermountingblocksupport[fgklayernumber];
4641 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4642 TGeoVolume* centerladdersupportpiece[fgklayernumber];
4643 char sidemountingblockname[40];
4644 char centermountingblockname[40];
4645 char sideladdersupportpiecename[40];
4646 char centerladdersupportpiecename[40];
4647 for(Int_t i=0; i<fgklayernumber; i++){
4648 sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4649 sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4650 sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4651 sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4652 sidemountingblocksupportshape[i] = new TGeoXtru(2);
4653 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4654 xsidevertex[i],ysidevertex[i]);
4655 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4656 -fgkMountingBlockSupportWidth[0]);
4657 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4658 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4659 sidemountingblocksupportshape[i],
4660 fSSDAlCoolBlockMedium);
4661 sidemountingblocksupport[i]->SetLineColor(9);
4662 centermountingsupportshape[i] = new TGeoXtru(2);
4663 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4664 xcentervertex[i],ycentervertex[i]);
4665 centermountingsupportshape[i]->DefineSection(0,0.);
4666 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4667 -fgkMountingBlockSupportWidth[0]);
4668 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4669 centermountingsupportshape[i],
4670 fSSDAlCoolBlockMedium);
4671 centermountingblocksupport[i]->SetLineColor(9);
4672 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4673 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4674 xsidelowervertex[i],ysidelowervertex[i]);
4675 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4676 -fgkMountingBlockSupportWidth[0]);
4677 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4678 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4679 sideladdersupportpieceshape[i],
4680 fSSDSupportRingAl);
4681 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4682 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4683 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4684 xcenterlowervertex[i],ycenterlowervertex[i]);
4685 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4686 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4687 -fgkMountingBlockSupportWidth[0]);
4688 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4689 centerladdersupportpieceshape[i],
4690 fSSDSupportRingAl);
4691 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4692 }
4693 /////////////////////////////////////////////////////////////
4694 // Building the Up Structure of Ladder Supports
4695 /////////////////////////////////////////////////////////////
4696 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4697 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4698 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4699 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4700 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4701 //////////////////////////////////////////////////////////
4702 // Setting the volume for TGeoXtru Mounting Block Piece
4703 //////////////////////////////////////////////////////////
4704 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4705 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4706 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4707 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4708 TGeoVolume* mountingblockpieceup[fgklayernumber];
4709 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4710 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4711 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4712 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
4713 char mountingblockpiecedownname[34];
4714 char mountingblockpieceupname[34];
4715 for(Int_t i=0; i<fgklayernumber; i++){
4716 ///////////////////////////
4717 // Mounting Block Down Vertex
4718 ///////////////////////////
4719 mountingblockpiecedownshape[i] = new TGeoXtru(2);
4720 sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4721 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4722 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4723 + fgkMountingBlockSupportDownHeight;
4724 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4725 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4726 + fgkSSDMountingBlockHeight[1]
4727 - 0.5*fgkCoolingTubeSupportHeight
4728 - fgkSSDModuleCoolingBlockToSensor;
4729 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4730 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4731 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4732 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4733 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4734 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4735 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4736 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4737 + fgkSSDMountingBlockHeight[2]
4738 - fgkSSDMountingBlockHeight[0];
4739 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4740 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4741 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4742 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4743 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4744 mountingblockpiecedownyvertex[i]);
4745 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4746 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4747 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
4748 mountingblockpiecedownshape[i],fSSDSupportRingAl);
4749 mountingblockpiecedown[i]->SetLineColor(fColorG10);
4750 ///////////////////////////
4751 // Mounting Block Up Vertex
4752 ///////////////////////////
4753 mountingblockpieceupshape[i] = new TGeoXtru(2);
4754 sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4755 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4756 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4757 + fgkMountingBlockSupportUpHeight[i];
4758 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4759 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4760 + fgkSSDMountingBlockHeight[1]
4761 - 0.5*fgkCoolingTubeSupportHeight
4762 - fgkSSDModuleCoolingBlockToSensor;
4763 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4764 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4765 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4766 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4767 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4768 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4769 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4770 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4771 + fgkSSDMountingBlockHeight[2]
4772 - fgkSSDMountingBlockHeight[0];
4773 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4774 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4775 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4776 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4777 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4778 mountingblockpieceupyvertex[i]);
4779 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4780 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4781 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
4782 mountingblockpieceupshape[i],fSSDSupportRingAl);
4783 mountingblockpieceup[i]->SetLineColor(fColorG10);
4784 }
4785 ///////////////////////////////////////////////////////////////////
4786 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4787 ///////////////////////////////////////////////////////////////////
4788 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4789 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4790 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4791 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4792 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4793 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4794 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4795 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4796 char mountingblocksupportrapezoidowname[40];
4797 char mountingblocksupportrapezoidupname[40];
4798 Double_t scalefactor = 3./4.;
4799 for(Int_t i=0; i<fgklayernumber; i++){
4800 ////////////////////////////////////////////
4801 // Mounting Block Support Down Trapezoid Vertex
4802 ////////////////////////////////////////////
4803 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4804 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4805 - mountingsupportedge[i];
4806 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4807 mountingblocksupportrapezoidownxvertex[i][1] =
4808 mountingblocksupportrapezoidownxvertex[i][0];
4809 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4810 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4811 - mountingblockpiecedownyvertex[i][0]);
4812 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4813 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4814 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4815 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4816 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4817 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4818 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4819 mountingblocksupportrapezoidownyvertex[i]);
4820 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4821 -fgkMountingBlockSupportWidth[0]);
4822 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4823 sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4824 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
4825 mountingblocksupportrapezoidownshape[i],fSSDMountingBlockMedium);
4826 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4827 ////////////////////////////////////////////
4828 // Mounting Block Support Up Trapezoid Vertex
4829 ////////////////////////////////////////////
4830 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4831 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4832 - mountingsupportedge[i];
4833 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4834 mountingblocksupportrapezoidupxvertex[i][1] =
4835 mountingblocksupportrapezoidupxvertex[i][0];
4836 mountingblocksupportrapezoidupyvertex[i][1] =
4837 mountingblockpieceupyvertex[i][0]
4838 + scalefactor*(mountingblockpieceupyvertex[i][1]
4839 - mountingblockpieceupyvertex[i][0]);
4840 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4841 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4842 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4843 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4844 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4845 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4846 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4847 mountingblocksupportrapezoidupyvertex[i]);
4848 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4849 -fgkMountingBlockSupportWidth[0]);
4850 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4851 sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4852 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
4853 mountingblocksupportrapezoidupshape[i],fSSDMountingBlockMedium);
4854 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4855 }
4856 ///////////////////////////////////////////////////////////////////
4857 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4858 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4859 Double_t boxoriginup[fgklayernumber][2][3];
4860 Double_t boxorigindown[fgklayernumber][2][3];
4861 char mountingblocksupportboxdownname[34];
4862 char mountingblocksupportboxupname[34];
4863 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4864 mountingblocksupportrot->SetAngles(90.,180.,-90);
4865 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4866 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4867 TGeoHMatrix* laddersupportmatrix[2];
4868 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4869 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4870 /////////////////////////////////////////////////////////////
4871 // Creating Mother Volume for Containment
4872 /////////////////////////////////////////////////////////////
4873 Double_t *xmothervertex[fgklayernumber];
4874 Double_t *ymothervertex[fgklayernumber];
4875 for(Int_t i=0; i<fgklayernumber; i++){
4876 xmothervertex[i] = new Double_t[8];
4877 ymothervertex[i] = new Double_t[8];
4878 }
4879 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4880 TGeoVolume* downmotherladdersupport[fgklayernumber];
4881 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4882 TGeoVolume* upmotherladdersupport[fgklayernumber];
4883 char upmotheladdersupportname[30];
4884 char downmotheladdersupportname[30];
4885 for(Int_t i=0; i<fgklayernumber; i++){
4886 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4887 - mountingsupportedge[i];
4888 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4889 xmothervertex[i][1] = xmothervertex[i][0];
4890 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4891 + fgkMountingBlockSupportWidth[0];
4892 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4893 ymothervertex[i][2] = ymothervertex[i][1];
4894 xmothervertex[i][3] = xmothervertex[i][2];
4895 ymothervertex[i][3] = -ymothervertex[i][0];
4896 xmothervertex[i][4] = -xmothervertex[i][0];
4897 ymothervertex[i][4] = ymothervertex[i][3];
4898 xmothervertex[i][5] = xmothervertex[i][4];
4899 ymothervertex[i][5] = -ymothervertex[i][1];
4900 xmothervertex[i][6] = -xmothervertex[i][2];
4901 ymothervertex[i][6] = ymothervertex[i][5];
4902 xmothervertex[i][7] = xmothervertex[i][6];
4903 ymothervertex[i][7] = ymothervertex[i][0];
4904 sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4905 sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
4906 downmotherladdersupportshape[i] = new TGeoXtru(2);
4907 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4908 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4909 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4910 + fgkMountingBlockSupportDownHeight
4911 + fgkSSDMountingBlockHeight[1]
4912 - 0.5*fgkCoolingTubeSupportHeight
4913 - fgkSSDModuleCoolingBlockToSensor);
4914 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4915 downmotherladdersupportshape[i],fSSDAir);
4916 upmotherladdersupportshape[i] = new TGeoXtru(2);
4917 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4918 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4919 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4920 + fgkMountingBlockSupportUpHeight[i]
4921 + fgkSSDMountingBlockHeight[1]
4922 - 0.5*fgkCoolingTubeSupportHeight
4923 - fgkSSDModuleCoolingBlockToSensor);
4924 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4925 upmotherladdersupportshape[i],fSSDAir);
4926 }
4927 for(Int_t i=0; i<fgklayernumber; i++){
4928 /////////////////////////
4929 // Setting the box origin
4930 /////////////////////////
4931 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4932 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
4933 + 0.5*fgkMountingBlockSupportDownHeight;
4934 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4935 - 0.5*fgkMountingBlockSupportWidth[0];
4936
4937 boxorigindown[i][1][0] = 0.0;
4938 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4939 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4940 - fgkMountingBlockSupportWidth[0]);
4941
4942 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4943 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4944 + 0.5*fgkMountingBlockSupportUpHeight[i];
4945 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4946 - 0.5*fgkMountingBlockSupportWidth[0];
4947
4948 boxoriginup[i][1][0] = 0.0;
4949 boxoriginup[i][1][1] = fgkMountingBlockSupportRadius[i]
4950 + 0.5*fgkMountingBlockSupportUpHeight[i];
4951 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4952 - fgkMountingBlockSupportWidth[0]);
4953
4954 /////////////////////////
4955 // Setting the boxes
4956 /////////////////////////
4957 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4958 + fgkSSDMountingBlockLength[0]),
4959 0.5*fgkMountingBlockSupportDownHeight,
4960 0.5*fgkMountingBlockSupportWidth[0],
4961 boxorigindown[i][0]);
4962 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4963 0.5*fgkMountingBlockSupportDownHeight,
4964 0.5*(fgkMountingBlockSupportWidth[1]
4965 - fgkMountingBlockSupportWidth[0]),
4966 boxorigindown[i][1]);
4967
4968 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4969 + fgkSSDMountingBlockLength[0]),
4970 0.5*fgkMountingBlockSupportUpHeight[i],
4971 0.5*fgkMountingBlockSupportWidth[0],
4972 boxoriginup[i][0]);
4973
4974 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4975 0.5*fgkMountingBlockSupportUpHeight[i],
4976 0.5*(fgkMountingBlockSupportWidth[1]
4977 - fgkMountingBlockSupportWidth[0]),
4978 boxoriginup[i][1]);
4979 ///////////////////////////////////////
4980 // Adding the Volumes to Mother Volume
4981 ///////////////////////////////////////
4982 for(Int_t j=0; j<2; j++){
4983 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4984 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4985 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4986 mountingblocksupportboxdownshape[i][j],
4987 fSSDMountingBlockMedium);
4988 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4989 mountingblocksupportboxupshape[i][j],
4990 fSSDMountingBlockMedium);
4991 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4992 mountingblocksupportboxup[i][j]->SetLineColor(9);
4993 for(Int_t k=0; k<2; k++){
4994 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4995 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4996 }
4997 }
4998 for(Int_t k=0; k<2; k++){
4999 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
5000 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
5001 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
5002 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
5003 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
5004 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
5005 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
5006 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
5007 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
5008 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
5009 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
5010 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
5011 }
5012 }
5013 TList* laddersupportlist = new TList();
5014 laddersupportlist->Add(downmotherladdersupport[0]);
5015 laddersupportlist->Add(upmotherladdersupport[0]);
5016 laddersupportlist->Add(downmotherladdersupport[1]);
5017 laddersupportlist->Add(upmotherladdersupport[1]);
5018 /////////////////////////////////////////////////////////////
5019 // Deallocating memory
5020 /////////////////////////////////////////////////////////////
5021 for(Int_t i=0; i<fgklayernumber; i++){
5022 for(Int_t j=0; j<nedges+1; j++)
5023 delete vertex[i][j];
5024 delete mountingsupportedgevector[i];
5025 delete [] vertex[i];
5026 delete vertexlist[i];
5027 delete [] xsidevertex[i];
5028 delete [] ysidevertex[i];
5029 delete [] xcentervertex[i];
5030 delete [] ycentervertex[i];
5031 delete [] xsidelowervertex[i];
5032 delete [] ysidelowervertex[i];
5033 delete [] xcenterlowervertex[i];
5034 delete [] ycenterlowervertex[i];
5035 }
5036 delete xsidevertex;
5037 delete ysidevertex;
5038 delete xcentervertex;
5039 delete ycentervertex;
5040 delete xsidelowervertex;
5041 delete ysidelowervertex;
5042 delete xcenterlowervertex;
5043 delete ycenterlowervertex;
5044 delete globalrefladdersupportrot;
5045 delete mountingblocksupportrot;
5046 /////////////////////
5047 return laddersupportlist;
5048}
5049 ////////////////////////////////////////////////////////////////////////////////
5050void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
5051//////////////////////////////////////////
5052// Method Generating Ladder Support Ring
5053//////////////////////////////////////////
5054 if(!fCreateMaterials) CreateMaterials();
5055 if(!fTransformationMatrices) CreateTransformationMatrices();
5056 if(!fBasicObjects) CreateBasicObjects();
5057 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
5058 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
5059 const Int_t kssdlayladdernumber[fgklayernumber] =
5060 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
5061 Double_t mountingsupportedge[fgklayernumber];
5062 Double_t mountingblockratio[fgklayernumber];
5063 Double_t theta[fgklayernumber];
5064 Double_t phi[fgklayernumber];
5065 for(Int_t i=0; i<fgklayernumber; i++){
5066 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
5067 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
5068 *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
5069 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
5070 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
5071 / kssdlayladdernumber[i])));
5072 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
5073 / fgkMountingBlockSupportRadius[i]);
5074 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
5075 }
5076 TGeoRotation* globalrot = new TGeoRotation();
5077 globalrot->SetAngles(0.,-90.,0.);
5078 TGeoRotation** laddersupportrot[fgklayernumber];
5079 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
5080 for(Int_t i=0; i<fgklayernumber; i++){
5081 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
5082 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
5083 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
5084 laddersupportrot[i][j] = new TGeoRotation();
5085 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
5086 switch(i){
5087 case 0: //Ladder of Layer5
5088 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
5089 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
5090 laddersupportmatrix[i][j]);
5091 break;
5092 case 1: //Ladder of Layer6
5093 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
5094 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
5095 laddersupportmatrix[i][j]);
5096 break;
5097 }
5098 }
5099 }
5100 /////////////////////////////////////////////////////////////
5101 // Creating Lower Ladder Support
5102 /////////////////////////////////////////////////////////////
5103 TVector3** ringsupportvertex[fgklayernumber];
5104 Double_t angle = 360./nedges;
5105 for(Int_t i=0; i<fgklayernumber; i++){
5106 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
5107 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
5108 * TMath::Cos(theta[i]));
5109 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
5110 - mountingsupportedge[i],
5111 ringsupportvertex[i][0]->Y());
5112 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
5113 ringsupportvertex[i][1]->Y());
5114 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
5115 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
5116 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
5117 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
5118 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
5119 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
5120 }
5121 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
5122 for(Int_t j=0; j<nedges+1; j++){
5123 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
5124 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*CosD(90.0-j*angle),
5125 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*SinD(90.0-j*angle));
5126 }
5127 }
5128 Double_t **xmothervertex = new Double_t*[fgklayernumber];
5129 Double_t **ymothervertex = new Double_t*[fgklayernumber];
5130 for(Int_t i=0; i<fgklayernumber; i++){
5131 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5132 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5133 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
5134 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
5135 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
5136 }
5137 }
5138 char lowerladdersupportname[30];
5139 TGeoXtru* lowerladdersupportshape[fgklayernumber];
5140 TGeoVolume* lowerladdersupport[fgklayernumber];
5141 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5142 lowerladdersupportrot->SetAngles(90.,180.,-90);
5143 for(Int_t i=0; i<fgklayernumber; i++){
5144 lowerladdersupportshape[i] = new TGeoXtru(2);
5145 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
5146 xmothervertex[i],ymothervertex[i]);
5147 lowerladdersupportshape[i]->DefineSection(0,0.);
5148 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
5149 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
5150 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
5151 lowerladdersupportshape[i],fSSDSupportRingAl);
5152 lowerladdersupport[i]->SetLineColor(fColorAl);
5153 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
5154 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
5155 }
5156 /////////////////////////////////////////////////////////////
5157 // Deallocating memory
5158 /////////////////////////////////////////////////////////////
5159 for(Int_t i=0; i<fgklayernumber; i++){
5160 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
5161 delete ringsupportvertex[i][j];
5162 delete [] ringsupportvertex[i];
5163 }
5164 for(Int_t i=0; i<fgklayernumber; i++){
5165 delete [] xmothervertex[i];
5166 delete [] ymothervertex[i];
5167 }
5168 delete xmothervertex;
5169 delete ymothervertex;
5170 delete globalrot;
5171 for(Int_t i=0; i<fgklayernumber; i++){
5172 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
5173 delete laddersupportrot[i][j];
5174 delete [] laddersupportrot[i];
5175 }
5176 }
5177 ////////////////////////////////////////////////////////////////////////////////
5178 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
5179 /////////////////////////////////////////////////////////////
5180 // Method generating Endcap CoverPlate
5181 /////////////////////////////////////////////////////////////
5182 // Holes Definition
5183 ///////////////////
5184 Int_t nendcapcoverplateholedges = 30;
5185 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
5186 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
5187 0.5*fgkEndCapCoverPlateThickness};
5188 TGeoXtru* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
5189 nendcapcoverplateholedges,holesection);
5190 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
5191 endcapcoverplatesmallholeshape,fSSDAir);
5192 endcapcoverplatesmallhole->SetLineColor(6);
5193 TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
5194 nendcapcoverplateholedges,holesection);
5195 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
5196 endcapcoverplatebigholeshape,fSSDAir);
5197 endcapcoverplatebighole->SetLineColor(6);
5198 //////////////////////////
5199 // Screw Piece Definition
5200 //////////////////////////
5201 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
5202 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
5203 CosD(0.5*smallscrewangle),
5204 0.5*fgkEndCapCoverPlateThickness);
5205 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
5206 endcapsmallscrewpieceshape,
5207 fSSDCoolingTubePhynox);
5208 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
5209 ///////////////////
5210 // Box Definition
5211 ///////////////////
5212 TGeoBBox* endcapcoverplateboxshape[4];
5213 TGeoVolume* endcapcoverplatebox[4];
5214 Double_t boxorigin[5][3];
5215 boxorigin[0][0] = 0.;
5216 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
5217 boxorigin[0][2] = 0.;
5218
5219 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
5220 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
5221 boxorigin[1][2] = 0.;
5222
5223 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
5224 + fgkEndCapCoverPlateSmallHoleSeparation[1];
5225 boxorigin[2][1] = boxorigin[1][1];
5226 boxorigin[2][2] = 0.;
5227
5228 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
5229 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
5230 boxorigin[3][1] = boxorigin[1][1];
5231 boxorigin[3][2] = 0.;
5232
5233 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5234 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5235 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
5236 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5237
5238 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5239 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5240 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5241 + fgkEndCapCoverPlateSmallHoleRadius,
5242 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5243
5244 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5245 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5246 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5247 + fgkEndCapCoverPlateSmallHoleRadius,
5248 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5249
5250 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5251 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5252 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5253 + fgkEndCapCoverPlateSmallHoleRadius,
5254 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5255
5256 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
5257 fSSDAir);
5258 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
5259 fSSDAir);
5260 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
5261 fSSDAir);
5262 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
5263 fSSDAir);
5264 endcapcoverplatebox[0]->SetLineColor(6);
5265 endcapcoverplatebox[1]->SetLineColor(6);
5266 endcapcoverplatebox[2]->SetLineColor(6);
5267 endcapcoverplatebox[3]->SetLineColor(6);
5268 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5269 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5270 fgkEndCapCoverPlateSmallHoleRadius,
5271 0.5*fgkEndCapCoverPlateThickness,
5272 endcapfillingboxorigin);
5273 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
5274 fSSDAir);
5275 endcapfillingbox->SetLineColor(6);
5276 ////////////////////////////
5277 // Contour Xtru Definition
5278 ////////////////////////////
5279 const Int_t kcontourvertexnumber = 10;
5280 Double_t xcontourvertex[kcontourvertexnumber];
5281 Double_t ycontourvertex[kcontourvertexnumber];
5282 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5283 xcontourvertex[1] = xcontourvertex[0];
5284 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5285 xcontourvertex[3] = xcontourvertex[2];
5286 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5287 xcontourvertex[5] = xcontourvertex[4];
5288 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5289 xcontourvertex[7] = xcontourvertex[6];
5290 xcontourvertex[8] = xcontourvertex[4];
5291 xcontourvertex[9] = xcontourvertex[8];
5292 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5293 - (kendcapcoverplatesmallholenumber[1]-1)
5294 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5295 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5296 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5297 ycontourvertex[2] = ycontourvertex[1];
5298 ycontourvertex[3] = ycontourvertex[0];
5299 ycontourvertex[4] = ycontourvertex[3];
5300 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5301 ycontourvertex[6] = ycontourvertex[5];
5302 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5303 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5304 + fgkEndCapCoverPlateSmallHoleRadius;
5305 ycontourvertex[8] = ycontourvertex[7];
5306 ycontourvertex[9] = ycontourvertex[0];
5307 TGeoXtru* contourshape = new TGeoXtru(2);
5308 contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex);
5309 contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5310 contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5311 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,fSSDAir);
5312 contour->SetLineColor(6);
5313 /////////////////////////////
5314 // Hole Contour Xtru Definition
5315 ////////////////////////////
5316 const Int_t kholecontourvertexnumber = 10;
5317 Double_t xholecontourvertex[2][kcontourvertexnumber];
5318 Double_t yholecontourvertex[2][kcontourvertexnumber];
5319 xholecontourvertex[0][0] = xcontourvertex[0];
5320 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5321 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5322 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5323 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5324 + 0.5*(fgkEndCapCoverPlateLength[2]
5325 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5326 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5327 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5328 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5329 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5330 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5331 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5332
5333 yholecontourvertex[0][0] = ycontourvertex[1];
5334 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5335 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5336 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5337 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5338 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5339 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5340 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5341 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5342 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5343 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5344
5345 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5346 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5347 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5348 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5349 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5350 + 0.5*(fgkEndCapCoverPlateLength[2]
5351 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5352 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5353 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5354 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5355 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5356 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5357 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5358
5359 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5360 - fgkEndCapCoverPlateWidth[0]);
5361 yholecontourvertex[1][1] = ycontourvertex[0];
5362 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5363 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5364 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5365 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5366 - fgkEndCapCoverPlateWidth[0]
5367 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5368 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5369 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5370 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5371 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5372
5373 TGeoXtru* holecontourshape[2];
5374 holecontourshape[0] = new TGeoXtru(2);
5375 holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0],
5376 yholecontourvertex[0]);
5377 holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5378 holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5379
5380 holecontourshape[1] = new TGeoXtru(2);
5381 holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1],
5382 yholecontourvertex[1]);
5383 holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5384 holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5385
5386 TGeoVolume* holecontour[2];
5387 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0],fSSDAir);
5388 holecontour[0]->SetLineColor(6);
5389 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1],fSSDAir);
5390 holecontour[1]->SetLineColor(6);
5391 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5392 + fgkEndCapCoverPlateLength[2],0.,0.);
5393 TGeoTranslation* bigholetrans[3];
5394 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5395 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5396 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5397 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5398 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5399 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5400 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5401 /////////////////////////////////
5402 // Mother Volume Xtru Definition
5403 /////////////////////////////////
5404 const Int_t kmothervertexnumber = 12;
5405 Double_t xmothervertex[kmothervertexnumber];
5406 Double_t ymothervertex[kmothervertexnumber];
5407 xmothervertex[0] = xcontourvertex[0];
5408 xmothervertex[1] = xmothervertex[0];
5409 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5410 xmothervertex[3] = xmothervertex[2];
5411 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5412 xmothervertex[5] = xmothervertex[4];
5413 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5414 xmothervertex[7] = xmothervertex[6];
5415 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5416 + fgkEndCapCoverPlateLength[2];
5417 xmothervertex[9] = xmothervertex[8];
5418 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5419 xmothervertex[11] = xmothervertex[10];
5420
5421 ymothervertex[0] = ycontourvertex[0];
5422 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5423 ymothervertex[2] = ymothervertex[1];
5424 ymothervertex[3] = ycontourvertex[1];
5425 ymothervertex[4] = ymothervertex[3];
5426 ymothervertex[5] = ymothervertex[1];
5427 ymothervertex[6] = ymothervertex[5];
5428 ymothervertex[7] = ymothervertex[0];
5429 ymothervertex[8] = ymothervertex[7];
5430 ymothervertex[9] = ymothervertex[8]
5431 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5432 ymothervertex[10] = ymothervertex[9];
5433 ymothervertex[11] = ymothervertex[8];
5434 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5435 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5436 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5437 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5438 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5439 ////////////////////////////////////////
5440 // Adding Nodes
5441 ////////////////////////////////////////
5442// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5443 TGeoTranslation*** endcapcoverplatesmallholetrans;
5444 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5445 Double_t transx[4] = {0,
5446 fgkEndCapCoverPlateSmallHoleSeparation[0],
5447 fgkEndCapCoverPlateSmallHoleSeparation[0]
5448 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5449 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5450 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5451 Int_t index = 0;
5452 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5453 endcapcoverplatesmallholetrans[i] =
5454 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5455 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5456 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5457 endcapcoverplatesmallholetrans[i][j] =
5458 new TGeoTranslation(transx[i],
5459 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5460 if(index!=10){
5461 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5462 index,endcapcoverplatesmallholetrans[i][j]);
5463 mothercoverplate->AddNode(endcapsmallscrewpiece,
5464 index,endcapcoverplatesmallholetrans[i][j]);
5465 }
5466 if(j<kendcapcoverplatesmallholenumber[1]-1)
5467 mothercoverplate->AddNode(endcapcoverplatebox[0],
5468 index,endcapcoverplatesmallholetrans[i][j]);
5469 }
5470 }
5471 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5472 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5473 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5474 mothercoverplate->AddNode(endcapfillingbox,1);
5475 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5476 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5477 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5478 mothercoverplate->AddNode(holecontour[0],1);
5479 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5480 mothercoverplate->AddNode(holecontour[1],1);
5481 mothercoverplate->AddNode(contour,1);
5482 /////////////////////////////////
5483 return mothercoverplate;
5484 }
5485 ////////////////////////////////////////////////////////////////////////////////
5486 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5487 /////////////////////////////////////////////////////////////
5488 // Getting EndCap Cooling Tube
5489 /////////////////////////////////////////////////////////////
5490 TGeoTorus* endcapcoolingtubetorushape[5];
5491 TGeoVolume* endcapcoolingtubetorus[5];
5492 TGeoTube* endcapcoolingtubeshape[4];
5493 TGeoVolume* endcapcoolingtube[4];
5494 char endcapcoolingtubetorusname[30];
5495 char endcapcoolingtubename[30];
5496 TGeoTorus* endcapcoolingwatertubetorushape[5];
5497 TGeoVolume* endcapcoolingwatertubetorus[5];
5498 TGeoTube* endcapcoolingwatertubeshape[4];
5499 TGeoVolume* endcapcoolingwatertube[4];
5500 char endcapcoolingwatertubetorusname[30];
5501 char endcapcoolingwatertubename[30];
5502 for(Int_t i=0; i<5; i++){
5503 sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5504 sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5505 sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5506 sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5507 if(i==3){
5508 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5509 fgkEndCapCoolingTubeRadiusMin,
5510 fgkEndCapCoolingTubeRadiusMax,
5511 90.0,fgkEndCapCoolingTubeAngle[3]);
5512 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5513 0.,fgkEndCapCoolingTubeRadiusMin,
5514 90.0,fgkEndCapCoolingTubeAngle[3]);
5515 }
5516 else{
5517 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5518 :fgkEndCapCoolingTubeAxialRadius[1],
5519 fgkEndCapCoolingTubeRadiusMin,
5520 fgkEndCapCoolingTubeRadiusMax,
5521 0.,fgkEndCapCoolingTubeAngle[i]);
5522 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5523 :fgkEndCapCoolingTubeAxialRadius[1],
5524 0.,fgkEndCapCoolingTubeRadiusMin,
5525 0.,fgkEndCapCoolingTubeAngle[i]);
5526 }
5527 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5528 endcapcoolingtubetorushape[i],
5529 fSSDCoolingTubePhynox);
5530 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5531 endcapcoolingwatertubetorushape[i],
5532 fSSDCoolingTubeWater);
5533 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5534 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5535 if(i<4){
5536 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5537 fgkEndCapCoolingTubeRadiusMax,
5538 0.5*fgkEndCapCoolingTubeLength[i]);
5539 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5540 0.5*fgkEndCapCoolingTubeLength[i]);
5541 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5542 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5543 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5544 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5545 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5546 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5547 }
5548 }
5549 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5550 /////////////////////////////////////////
5551 // Transformation for Volume Positioning
5552 /////////////////////////////////////////
5553 TGeoCombiTrans* coolingtubecombitrans[6];
5554 TGeoRotation* coolingtuberot[8];
5555 TGeoTranslation* coolingtubetrans[6];
5556 TGeoHMatrix* coolingtubematrix[4];
5557 TGeoCombiTrans* torustubecombitrans[4];
5558 TGeoRotation* torustuberot[7];
5559 TGeoTranslation* torustubetrans[4];
5560 TGeoHMatrix* torustubematrix[5];
5561 TGeoCombiTrans* coolingwatertubecombitrans[6];
5562 TGeoRotation* coolingwatertuberot[8];
5563 TGeoTranslation* coolingwatertubetrans[6];
5564 TGeoHMatrix* coolingwatertubematrix[4];
5565 TGeoCombiTrans* toruswatertubecombitrans[4];
5566 TGeoRotation* toruswatertuberot[7];
5567 TGeoTranslation* toruswatertubetrans[4];
5568 TGeoHMatrix* toruswatertubematrix[5];
5569 for(Int_t i=0; i<8; i++){
5570 if(i<6){
5571 coolingtubetrans[i] = new TGeoTranslation();
5572 coolingwatertubetrans[i] = new TGeoTranslation();
5573 }
5574 if(i<8){
5575 coolingtuberot[i] = new TGeoRotation();
5576 coolingwatertuberot[i] = new TGeoRotation();
5577 }
5578 if(i<4){
5579 torustubetrans[i] = new TGeoTranslation();
5580 toruswatertubetrans[i] = new TGeoTranslation();
5581 }
5582 if(i<7){
5583 torustuberot[i] = new TGeoRotation();
5584 toruswatertuberot[i] = new TGeoRotation();
5585 }
5586 }
5587 /////////////////////////////////////////
5588 // Transformation for Inox Volume Positioning
5589 /////////////////////////////////////////
5590 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5591 -endcapcoolingtubeshape[0]->GetDz(),0.);
5592 coolingtuberot[0]->SetAngles(0.,90.,0.);
5593 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5594 *coolingtuberot[0]);
5595
5596 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5597 coolingtuberot[1]->SetAngles(0.,90.,0.);
5598 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5599 *coolingtuberot[1]);
5600
5601 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5602 *CosD(fgkEndCapCoolingTubeAngle[0]),
5603 fgkEndCapCoolingTubeAxialRadius[0]
5604 *SinD(fgkEndCapCoolingTubeAngle[0]),
5605 0.);
5606 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5607 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5608 *coolingtuberot[2]);
5609
5610 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5611 * (*coolingtubecombitrans[1]));
5612
5613 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5614 endcapcoolingtubeshape[1]->GetDz());
5615 torustuberot[0]->SetAngles(0.,90.,0.);
5616 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5617
5618 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5619
5620 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5621 -endcapcoolingtubeshape[2]->GetDz(),0.);
5622 coolingtuberot[3]->SetAngles(0.,90.,0.);
5623 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5624 *coolingtuberot[3]);
5625 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5626 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5627 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5628
5629 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5630 endcapcoolingtubeshape[2]->GetDz());
5631 torustuberot[1]->SetAngles(0.,90.,0.);
5632 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5633 torustuberot[2]->SetAngles(180.,0.,0.);
5634 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5635 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5636
5637 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5638 -fgkEndCapCoolingTubeAxialRadius[0]);
5639 torustuberot[3]->SetAngles(0.,90.,0.);
5640 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5641 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5642 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5643 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5644
5645 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5646 fgkEndCapCoolingTubeAxialRadius[0],0.);
5647 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5648 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5649 *coolingtuberot[5]);
5650 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5651 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5652 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5653
5654 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5655 endcapcoolingtubeshape[0]->GetDz());
5656 torustuberot[5]->SetAngles(0.,90.,0.);
5657 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5658 torustuberot[6]->SetAngles(-90.,0.,0.);
5659 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5660 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5661
5662 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5663 endcapcoolingtubeshape[3]->GetDz(),0.);
5664 coolingtuberot[6]->SetAngles(0.,90.,0.);
5665 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5666 *coolingtuberot[6]);
5667 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5668 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5669 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5670 /////////////////////////////////////////
5671 // Transformation for Water Volume Positioning
5672 /////////////////////////////////////////
5673 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5674 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5675 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5676 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5677 *coolingwatertuberot[0]);
5678
5679 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5680 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5681 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5682 *coolingwatertuberot[1]);
5683
5684 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5685 *CosD(fgkEndCapCoolingTubeAngle[0]),
5686 fgkEndCapCoolingTubeAxialRadius[0]
5687 *SinD(fgkEndCapCoolingTubeAngle[0]),
5688 0.);
5689 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5690 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5691 *coolingwatertuberot[2]);
5692
5693 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5694 * (*coolingwatertubecombitrans[1]));
5695
5696 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5697 endcapcoolingwatertubeshape[1]->GetDz());
5698 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5699 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5700 *toruswatertuberot[0]);
5701
5702 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5703 * (*toruswatertubecombitrans[0]));
5704
5705 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5706 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5707 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5708 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5709 *coolingwatertuberot[3]);
5710 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5711 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5712 * (*coolingwatertubecombitrans[3]));
5713 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5714
5715 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5716 endcapcoolingwatertubeshape[2]->GetDz());
5717 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5718 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5719 *toruswatertuberot[1]);
5720 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5721 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5722 * (*toruswatertubecombitrans[1]));
5723 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5724
5725 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5726 -fgkEndCapCoolingTubeAxialRadius[0]);
5727 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5728 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5729 *toruswatertuberot[3]);
5730 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5731 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5732 * (*toruswatertubecombitrans[2]));
5733 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5734
5735 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5736 fgkEndCapCoolingTubeAxialRadius[0],0.);
5737 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5738 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5739 *coolingwatertuberot[5]);
5740 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5741 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5742 * (*coolingwatertubecombitrans[4]));
5743 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5744
5745 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5746 endcapcoolingwatertubeshape[0]->GetDz());
5747 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5748 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5749 *toruswatertuberot[5]);
5750 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5751 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5752 * (*toruswatertubecombitrans[3]));
5753 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5754
5755 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5756 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5757 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5758 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5759 *coolingwatertuberot[6]);
5760 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5761 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5762 * (*coolingwatertubecombitrans[5]));
5763 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5764 /////////////////////////////////////////
5765 // Positioning Volumes
5766 /////////////////////////////////////////
5767 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5768 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5769
5770 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5771 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5772
5773 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5774 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5775
5776 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5777 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5778
5779 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5780 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5781
5782 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5783 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5784
5785 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5786 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5787
5788 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5789 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5790
5791 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5792 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5793
5794 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5795 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5796 /////////////////////////////////////////////////////////////
5797 // Deallocating memory
5798 /////////////////////////////////////////////////////////////
5799 for(Int_t i=0; i<8; i++){
5800 if(i<6){
5801 delete coolingtubetrans[i];
5802 delete coolingwatertubetrans[i];
5803 if(i!=0){
5804 delete coolingtubecombitrans[i];
5805 delete coolingwatertubecombitrans[i];
5806 }
5807 }
5808 if(i<8){
5809 delete coolingtuberot[i];
5810 delete coolingwatertuberot[i];
5811 }
5812 if(i<4){
5813 delete torustubetrans[i];
5814 delete toruswatertubetrans[i];
5815 delete torustubecombitrans[i];
5816 delete toruswatertubecombitrans[i];
5817 }
5818 if(i<7){
5819 delete torustuberot[i];
5820 delete toruswatertuberot[i];
5821 }
5822 }
5823 /////////////////////////////////////////////////////////////
5824 return endcapcoolingtubemother;
5825 }
5826 ////////////////////////////////////////////////////////////////////////////////
5827 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5828 /////////////////////////////////////////////////////////////
5829 // Getting EndCap Cover Side
5830 /////////////////////////////////////////////////////////////
5831 const Int_t kendcapcoverholenumber[2] = {7,5};
5832 const Int_t kvertexnumber = 15;
5833 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5834 xvertex[0] = 0.0;
5835 xvertex[1] = xvertex[0];
5836 xvertex[2] = fgkEndCapSideCoverLength[0];
5837 xvertex[3] = fgkEndCapSideCoverLength[1];
5838 xvertex[4] = xvertex[3];
5839 xvertex[5] = fgkEndCapSideCoverLength[2];
5840 xvertex[6] = xvertex[5];
5841 xvertex[7] = xvertex[2];
5842 xvertex[8] = xvertex[7];
5843 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5844 xvertex[10] = xvertex[9];
5845 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5846 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5847 * fgkEndCapSideCoverLength[4];
5848 xvertex[12] = xvertex[11];
5849 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5850 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5851 * fgkEndCapSideCoverLength[4];
5852 xvertex[14] = xvertex[13];
5853 yvertex[0] = 0.0;
5854 yvertex[1] = fgkEndCapSideCoverWidth[0];
5855 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5856 yvertex[3] = yvertex[2];
5857 yvertex[4] = fgkEndCapSideCoverWidth[1];
5858 yvertex[5] = yvertex[4];
5859 yvertex[6] = yvertex[0];
5860 yvertex[7] = yvertex[6];
5861 yvertex[8] = fgkEndCapSideCoverWidth[6];
5862 yvertex[9] = yvertex[8];
5863 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5864 yvertex[11] = yvertex[10];
5865 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5866 yvertex[13] = yvertex[12];
5867 yvertex[14] = yvertex[6];
5868 TGeoXtru* endcapsidecovershape = new TGeoXtru(2);
5869 endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex);
5870 endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5871 endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5872 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5873 endcapsidecovershape,fSSDCoolingTubePhynox);
5874 endcapsidecover->SetLineColor(fColorPhynox);
5875 ////////////////////////////////////////////
5876 // Defininition of Mother Volume
5877 ////////////////////////////////////////////
5878 const Int_t kmothervertexnumber = 7;
5879 Double_t xmothervertex[kmothervertexnumber];
5880 Double_t ymothervertex[kmothervertexnumber];
5881 for(Int_t i=0; i<kmothervertexnumber; i++){
5882 xmothervertex[i] = xvertex[i];
5883 ymothervertex[i] = yvertex[i];
5884 }
5885 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5886 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5887 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5888 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5889 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5890 endcapsidecovermothershape,fSSDAir);
5891 ////////////////////////////////////////////
5892 endcapsidecovermother->AddNode(endcapsidecover,1);
5893 TGeoBBox* endcapsidecoverboxshape[4];
5894 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5895 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5896 0.5*fgkEndCapSideCoverLength[4],
5897 0.5*fgkEndCapSideCoverThickness);
5898 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5899 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5900 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5901 - fgkEndCapSideCoverLength[4]),
5902 0.5*fgkEndCapSideCoverThickness);
5903 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5904 0.5*fgkEndCapSideCoverLength[4],
5905 0.5*fgkEndCapSideCoverThickness);
5906 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5907 0.5*fgkEndCapSideCoverWidth[5],
5908 0.5*fgkEndCapSideCoverThickness);
5909 TGeoVolume* endcapsidecoverbox[4];
5910 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5911 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5912 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5913 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5914 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5915// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5916 TGeoTranslation** endcapsidecoverboxtrans;
5917 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5918 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5919 + fgkEndCapSideCoverLength[0],
5920 endcapsidecoverboxshape[0]->GetDY()
5921 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5922 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5923 + xvertex[11],
5924 endcapsidecoverboxshape[1]->GetDY()
5925 + yvertex[12],0.);
5926 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5927 + xvertex[11],
5928 endcapsidecoverboxshape[2]->GetDY()
5929 + yvertex[12]
5930 + 2.*endcapsidecoverboxshape[1]->GetDY()
5931 + fgkEndCapSideCoverWidth[5],0.);
5932 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5933 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5934 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5935 for(Int_t i=0; i<2; i++)
5936 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5937 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5938 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5939 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5940 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5941 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5942 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5943 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5944 }
5945 for(Int_t i=0; i<2; i++)
5946 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5947 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5948 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5949 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5950 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5951 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5952 +fgkEndCapSideCoverLength[4]),0.0);
5953 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5954 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5955 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5956 +i*(kendcapcoverholenumber[1]-1)+j]);
5957 }
5958 return endcapsidecovermother;
5959 }
5960 ////////////////////////////////////////////////////////////////////////////////
5961 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5962 ////////////////////////////////////////////////////////////////////////////////
5963 // Method returning Interface Card A, Interface Card B, Supply Card
5964 ////////////////////////////////////////////////////////////////////////////////
5965 /////////////////////
5966 // Supply Card
5967 /////////////////////
5968 // Electronic Board Back Al Plane
5969 const Int_t kelectboardbackvertexnumber = 8;
5970 Double_t xelectboardback[kelectboardbackvertexnumber];
5971 Double_t yelectboardback[kelectboardbackvertexnumber];
5972 xelectboardback[0] = 0.0;
5973 xelectboardback[1] = xelectboardback[0];
5974 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5975 xelectboardback[3] = xelectboardback[2];
5976 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5977 xelectboardback[5] = xelectboardback[4];
5978 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5979 xelectboardback[7] = xelectboardback[6];
5980
5981 yelectboardback[0] = 0.0;
5982 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5983 yelectboardback[2] = yelectboardback[1];
5984 yelectboardback[3] = yelectboardback[0];
5985 yelectboardback[4] = yelectboardback[3];
5986 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5987 yelectboardback[6] = yelectboardback[5];
5988 yelectboardback[7] = yelectboardback[4];
5989 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5990 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5991 xelectboardback,yelectboardback);
5992 electboardbackshape->DefineSection(0,0.0);
5993 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5994 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5995 electboardbackshape,fSSDSupportRingAl);
5996 electboardback->SetLineColor(fColorAl);
5997 // Electronic Board Kapton Layer
5998 const Int_t kelectlayervertexnumber = 8;
5999 Double_t xelectlayer[kelectlayervertexnumber];
6000 Double_t yelectlayer[kelectlayervertexnumber];
6001 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
6002 xelectlayer[1] = xelectlayer[0];
6003 xelectlayer[2] = fgkEndCapCardElectBoardLength;
6004 xelectlayer[3] = xelectlayer[2];
6005 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
6006
6007 yelectlayer[0] = 0.0;
6008 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
6009 yelectlayer[2] = yelectlayer[1];
6010 yelectlayer[3] = yelectlayer[0];
6011 yelectlayer[4] = yelectlayer[3];
6012 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
6013 yelectlayer[6] = yelectlayer[5];
6014 yelectlayer[7] = yelectlayer[4];
6015 TGeoXtru* electlayershape = new TGeoXtru(2);
6016 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
6017 electlayershape->DefineSection(0,0.0);
6018 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
6019 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
6020 electlayershape,fSSDKaptonFlexMedium);
6021 electlayer->SetLineColor(fColorKapton);
6022 // JMD Connector Female
6023 const Int_t kjmdconnectorvertexnumber = 6;
6024 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
6025 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
6026 xjmdconnectorvertex[0] = 0.0;
6027 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
6028 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
6029 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
6030 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
6031 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
6032
6033 yjmdconnectorvertex[0] = 0.0;
6034 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
6035 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
6036 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
6037 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
6038 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
6039 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
6040 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
6041 yjmdconnectorvertex);
6042 jmdconnectorshape->DefineSection(0,0.0);
6043 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
6044 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
6045 jmdconnectorshape,fSSDMountingBlockMedium);
6046 jmdconnector->SetLineColor(fColorG10);
6047 // Top Cable Connector
6048 const Int_t kcableconnectorvertexnumber = 8;
6049 Double_t xconnectorvertex[kcableconnectorvertexnumber];
6050 Double_t yconnectorvertex[kcableconnectorvertexnumber];
6051 xconnectorvertex[0] = 0.0;
6052 xconnectorvertex[1] = xconnectorvertex[0];
6053 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
6054 xconnectorvertex[3] = xconnectorvertex[2];
6055 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
6056 - fgkEndCapCardCableConnectorLength[2];
6057 xconnectorvertex[5] = xconnectorvertex[4];
6058 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
6059 xconnectorvertex[7] = xconnectorvertex[6];
6060
6061 yconnectorvertex[0] = 0.0;
6062 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
6063 yconnectorvertex[2] = yconnectorvertex[1];
6064 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
6065 yconnectorvertex[4] = yconnectorvertex[3];
6066 yconnectorvertex[5] = yconnectorvertex[1];
6067 yconnectorvertex[6] = yconnectorvertex[5];
6068 yconnectorvertex[7] = yconnectorvertex[0];
6069 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
6070 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
6071 yconnectorvertex);
6072 cableconnectorshape->DefineSection(0,0.0);
6073 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
6074 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
6075 cableconnectorshape,fSSDMountingBlockMedium);
6076 cableconnector->SetLineColor(fColorG10);
6077 // Strip Connection
6078 TGeoBBox* endcapstripconnectionshape =
6079 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
6080 0.5*fgkEndCapStripConnectionThickness,
6081 0.5*fgkEndCapStripConnectionWidth);
6082 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
6083 endcapstripconnectionshape,
6084 fSSDSupportRingAl);
6085 endcapstripconnection->SetLineColor(fColorAl);
6086 // Interface Card B
6087 const Int_t kcardBvertexnumber = 12;
6088 Double_t xcardBvertexnumber[kcardBvertexnumber];
6089 Double_t ycardBvertexnumber[kcardBvertexnumber];
6090
6091 xcardBvertexnumber[0] = 0.0;
6092 xcardBvertexnumber[1] = xcardBvertexnumber[0];
6093 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
6094 xcardBvertexnumber[3] = xcardBvertexnumber[2];
6095 xcardBvertexnumber[4] = xcardBvertexnumber[1];
6096 xcardBvertexnumber[5] = xcardBvertexnumber[4];
6097 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
6098 xcardBvertexnumber[7] = xcardBvertexnumber[6];
6099 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
6100 xcardBvertexnumber[9] = xcardBvertexnumber[8];
6101 xcardBvertexnumber[10] = xcardBvertexnumber[7];
6102 xcardBvertexnumber[11] = xcardBvertexnumber[10];
6103
6104 ycardBvertexnumber[0] = 0.0;
6105 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
6106 ycardBvertexnumber[2] = ycardBvertexnumber[1];
6107 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
6108 ycardBvertexnumber[4] = ycardBvertexnumber[3];
6109 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
6110 ycardBvertexnumber[6] = ycardBvertexnumber[5];
6111 ycardBvertexnumber[7] = ycardBvertexnumber[4];
6112 ycardBvertexnumber[8] = ycardBvertexnumber[7];
6113 ycardBvertexnumber[9] = ycardBvertexnumber[1];
6114 ycardBvertexnumber[10] = ycardBvertexnumber[9];
6115 ycardBvertexnumber[11] = ycardBvertexnumber[0];
6116
6117 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
6118 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
6119 interfacecardBshape->DefineSection(0,0.);
6120 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
6121 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
6122 fSSDMountingBlockMedium);
6123 interfacecardB->SetLineColor(46);
6124 // Interface Card B Electronic Board
6125 const Int_t kelectboardcardBvertexnumber = 14;
6126 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
6127 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
6128
6129 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
6130 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
6131 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
6132 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
6133 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
6134 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
6135 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6136 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
6137 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6138 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
6139 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6140 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6141 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6142 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6143
6144 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6145 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6146 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
6147 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6148 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
6149 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
6150 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
6151 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6152 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
6153 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6154 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6155 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6156 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6157 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6158
6159 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6160 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6161 xelectboardcardBvertex,yelectboardcardBvertex);
6162 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6163 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6164 + fgkEndCapInterfaceElectBoardCardBThickness);
6165 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6166 fSSDSupportRingAl);
6167 electboardcardB->SetLineColor(fColorAl);
6168 // Generating Stiffener 2
6169 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6170 0.5*fgkEndCapStiffenerThickness,
6171 0.5*fgkEndCapStiffenerLength);
6172 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6173 endcapstiffener->SetLineColor(fColorAl);
6174 // Generating Mother Interface Card B Container
6175 const Int_t kinterfacecardBmothervertexnumber = 10;
6176 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6177 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6178
6179 xinterfacecardBmothervertex[0] = 0.0;
6180 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6181 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6182 + fgkEndCapInterfaceCardBThickness;
6183 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6184 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6185 + fgkEndCapInterfaceElectBoardCardBThickness;
6186 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6187 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6188 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6189 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6190 + fgkEndCapCardJMDConnectorLength[0];
6191 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6192
6193 yinterfacecardBmothervertex[0] = 0.0;
6194 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6195 + fgkEndCapInterfaceCardBWidth[1]
6196 + fgkEndCapInterfaceCardBWidth[2];
6197 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6198 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6199 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6200 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6201 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6202 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6203 + fgkEndCapCardJMDConnectorWidth[0]
6204 + fgkEndCapCardJMDConnectorWidth[1];
6205 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6206 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6207 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6208 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6209 xinterfacecardBmothervertex,
6210 yinterfacecardBmothervertex);
6211 interfacecardBmothershape->DefineSection(0,-1.e-15);
6212 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6213 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6214 interfacecardBmothershape,fSSDAir);
6215 electboardcardB->SetLineColor(fColorAl);
6216 // Positioning Volumes Mother Interface Card B Container
6217 TGeoRotation* interfacecardBrot = new TGeoRotation();
6218 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6219 interfacecardBrot->SetAngles(90.,-90.,-90.);
6220 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6221 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6222 TGeoRotation* electboardcardBrot = new TGeoRotation();
6223 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6224 electboardcardBrot->SetAngles(90.,90.,-90.);
6225 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6226 TGeoCombiTrans* electboardcardBcombitrans =
6227 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6228 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6229 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6230 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6231 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6232 TGeoTranslation* jmdconnectorcardBtrans[3];
6233 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6234 for(Int_t i=0; i<3; i++){
6235 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6236 + fgkEndCapCardJMDConnectorLength[0],
6237 fgkEndCapCardElectBoardLayerWidth[1],
6238 0.5*fgkEndCapCardJMDConnectorThickness
6239 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6240 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6241 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6242 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6243 *jmdconnectorcardBrot);
6244 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6245 }
6246 // Mother Supply Card Container
6247 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6248 // Interface Card Container
6249 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6250 // Placing Volumes in Mother Supply Card Container
6251 // JMD Connector Positioning
6252 TGeoTranslation* jmdconnectortrans[2];
6253 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6254 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6255 fgkEndCapCardElectBoardBackLength[0]
6256 - fgkEndCapCardJMDConnectorThickness
6257 - fgkEndCapCardJMDConnectorToLayer);
6258 TGeoRotation* jmdconnectorot = new TGeoRotation();
6259 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6260 + 2.*fgkEndCapCardJMDConnectorLength[0]
6261 + 2.*fgkEndCapCardElectBoardLayerThickness,
6262 fgkEndCapCardElectBoardLayerWidth[1],
6263 fgkEndCapCardJMDConnectorThickness
6264 + fgkEndCapCardJMDConnectorToLayer);
6265 jmdconnectorot->SetAngles(90.,180.,-90);
6266 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6267 * jmdconnectorot);
6268 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6269 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6270 // Top Cable Connector Placing
6271 TGeoRotation* cableconnectorot[2];
6272 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6273 TGeoTranslation* cableconnectortrans[3];
6274 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6275 cableconnectorot[0]->SetAngles(90.,0.,0.);
6276 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6277 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6278 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6279 *cableconnectorot[0]);
6280 TGeoHMatrix* cableconnectormatrix[2];
6281 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6282 new TGeoHMatrix((*cableconnectorot[1])
6283 *(*cableconnectorcombitrans));
6284 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6285 - fgkEndCapCardCableConnectorThickness,
6286 fgkEndCapCardCableConnectorLength[0]
6287 + fgkEndCapCardCableConnectorToLayer);
6288 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6289 - 2.*fgkEndCapCardCableConnectorThickness
6290 - fgkEndCapCardCableConnectorDistance,
6291 fgkEndCapCardCableConnectorLength[0]
6292 + fgkEndCapCardCableConnectorToLayer);
6293 for(Int_t i=0; i<2; i++){
6294 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6295 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6296 }
6297 TGeoRotation* electboardbackrot = new TGeoRotation();
6298 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6299 electboardbackrot->SetAngles(90.,-90.,-90.);
6300 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6301 + fgkEndCapCardJMDConnectorLength[0]
6302 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6303 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6304 *electboardbackrot);
6305 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6306 // Electronic Board Kapton Layer Positioning
6307 TGeoRotation* electlayerrot = new TGeoRotation();
6308 TGeoTranslation* electlayertrans[2];
6309 TGeoCombiTrans* electlayercombitrans[2];
6310 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6311 electlayerrot->SetAngles(90.,-90.,-90.);
6312 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6313 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6314 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6315 + 2.*fgkEndCapCardElectBoardLayerThickness
6316 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6317 for(Int_t i=0; i<2; i++){
6318 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6319 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6320 }
6321 // Placing Volumes in Mother Interface Card Container
6322 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6323 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6324 for(Int_t i=0; i<2; i++){
6325 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6326 }
6327 /////////////////////////////////////////////////////////////
6328 // Generation of Card Interface Container
6329 /////////////////////////////////////////////////////////////
6330 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6331 - fgkEndCapCardJMDConnectorLength[0]
6332 - fgkEndCapInterfaceCardBThickness
6333 - 9.*fgkEndCapStripConnectionThickness
6334 - 8.*fgkEndCapCardElectBoardBackThickness;
6335 const Int_t kcardinterfacecontainervertexnumber = 14;
6336 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6337 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6338 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6339 - 7.0*fgkEndCapStripConnectionThickness;
6340 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6341 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6342 + fgkEndCapStripConnectionThickness
6343 - fgkEndCapCardElectBoardLayerThickness
6344 - fgkEndCapCardCableConnectorWidth[0];
6345 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6346 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6347 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6348 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6349 + 2.0*fgkEndCapStripConnectionThickness;
6350 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6351 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6352 + fgkEndCapInterfaceCardBThickness;
6353 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6354 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6355 + fgkEndCapInterfaceElectBoardCardBThickness;
6356 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6357 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6358 - fgkEndCapInterfaceElectBoardCardBThickness
6359 + fgkEndCapCardJMDConnectorLength[0]
6360 + stiffenertransx+fgkEndCapStiffenerWidth;
6361 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6362
6363 ycardinterfacecontainervertex[0] = 0.;
6364 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6365 + fgkEndCapCardJMDConnectorWidth[0]
6366 + fgkEndCapCardJMDConnectorWidth[1];
6367 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6368 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6369 - fgkEndCapStripConnectionWidth;
6370 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6371 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6372 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6373 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6374 + fgkEndCapInterfaceCardBWidth[1]
6375 + fgkEndCapInterfaceCardBWidth[2];
6376 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6377 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6378 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6379 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6380 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6381 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6382
6383 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6384 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6385 xcardinterfacecontainervertex,
6386 ycardinterfacecontainervertex);
6387 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6388 - fgkEndCapCardElectBoardBackLength[0]));
6389 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6390 + fgkEndCapCardElectBoardBackLength[0]));
6391 TGeoVolume** cardinterfacecontainer;
6392 cardinterfacecontainer = new TGeoVolume*[4];
6393 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6394 interfacecardmothershape,fSSDAir);
6395 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6396 interfacecardmothershape,fSSDAir);
6397 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6398 interfacecardmothershape,fSSDAir);
6399 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6400 interfacecardmothershape,fSSDAir);
6401 /////////////////////////////////
6402 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6403 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6404 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6405 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6406 /////////////////////////////////
6407 TGeoRotation* endcapstripconnectionrot[2];
6408 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6409 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6410 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6411 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6412 * (*endcapstripconnectionrot[0]));
6413 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6414 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6415 -0.5*fgkEndCapCardElectBoardBackThickness,
6416 fgkEndCapCardElectBoardBackWidth[0]
6417 -endcapstripconnectionshape->GetDZ(),
6418 0.5*fgkEndCapCardElectBoardBackLength[0]);
6419 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6420 TGeoTranslation* cardinterfacetrans[9];
6421 TGeoHMatrix* cardinterfacematrix[9];
6422 for(Int_t i=0; i<7; i++){
6423 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6424 + fgkEndCapCardElectBoardBackThickness),
6425 0.0,0.0);
6426 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6427 * (*endcapstripconnectionmatrix));
6428 }
6429 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6430 + fgkEndCapCardElectBoardBackThickness),
6431 0.0,0.0);
6432 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6433 * (*endcapstripconnectionmatrix));
6434 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6435 + fgkEndCapCardElectBoardBackThickness),
6436 0.0,0.0);
6437 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6438 * (*endcapstripconnectionmatrix));
6439
6440 for(Int_t i=0; i<4; i++){
6441 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6442 cardinterfacematrix[7]);
6443 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6444 cardinterfacematrix[8]);
6445 }
6446 TGeoTranslation* mothersupplycardtrans =
6447 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6448 + 2.*fgkEndCapCardJMDConnectorLength[0]
6449 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6450 TGeoHMatrix* mothersupplycardmatrix[7];
6451 Int_t index[4] = {1,1,1,1};
6452 for(Int_t i=0; i<7; i++){
6453 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6454 * (*mothersupplycardtrans));
6455 for(Int_t j=0; j<4; j++){
6456 switch(j){
6457 case 0: //Layer5 EndCap Left Side
6458 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6459 cardinterfacematrix[i]);
6460 if(i!=0){
6461 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6462 mothersupplycardmatrix[i]);
6463 index[j]++;
6464
6465 }
6466 break;
6467 case 1: //Layer5 EndCap Rigth Side
6468 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6469 cardinterfacematrix[i]);
6470 if(i>0&&i<6){
6471 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6472 mothersupplycardmatrix[i]);
6473 index[j]++;
6474 }
6475 break;
6476 case 2: //Layer6 EndCap Left Side
6477 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6478 cardinterfacematrix[i]);
6479 if(i!=6){
6480 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6481 mothersupplycardmatrix[i]);
6482 index[j]++;
6483 }
6484 break;
6485 case 3: //Layer6 EndCap Right Side
6486 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6487 cardinterfacematrix[i]);
6488 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6489 mothersupplycardmatrix[i]);
6490 index[j]++;
6491 break;
6492 }
6493 }
6494 }
6495 // Positioning Interface
6496 TGeoTranslation* motherinterfacecardtrans =
6497 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6498 +0.5*fgkEndCapCardElectBoardBackThickness
6499 -fgkEndCapCardElectBoardLayerThickness
6500 +fgkEndCapStripConnectionThickness,0.,0.);
6501 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6502 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6503 // Positioning Interface Card B
6504 TGeoTranslation* interfacecardBmothertrans =
6505 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6506 + 2.*fgkEndCapStripConnectionThickness
6507 + fgkEndCapCardElectBoardBackThickness,0.,
6508 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6509 - fgkEndCapCardElectBoardBackLength[0]));
6510 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6511 interfacecardBmothertrans);
6512 // Positioning Stiffener
6513 TGeoTranslation* endcapstiffenertrans =
6514 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6515 + 2.0*fgkEndCapStripConnectionThickness
6516 + fgkEndCapInterfaceCardBThickness
6517 + fgkEndCapCardJMDConnectorLength[0]
6518 + stiffenertransx
6519 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6520 endcapstiffenershape->GetDZ()
6521 - 0.5*(fgkEndCapStiffenerLength
6522 - fgkEndCapCardElectBoardBackLength[0]));
6523 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6524 /////////////////////////////////////////////////////////////
6525 // Deallocating memory
6526 /////////////////////////////////////////////////////////////
6527 delete interfacecardBrot;
6528 delete interfacecardBtrans;
6529 delete electboardcardBtrans;
6530 delete electboardcardBrot;
6531 delete jmdconnectorcardBrot;
6532 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6533 delete jmdconnectorot;
6534 delete jmdconnectortrans[1];
6535 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6536 delete cableconnectorcombitrans;
6537 delete electboardbacktrans;
6538 delete electboardbackrot;
6539 delete electlayerrot;
6540 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6541 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6542 delete mothersupplycardtrans;
6543 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6544 /////////////////////////////////////////////////////////////
6545 return cardinterfacecontainer;
6546 }
6547 ////////////////////////////////////////////////////////////////////////////////
6548 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6549 /////////////////////////////////////////////////////////////
6550 // Method returning EndCap Mother Volume
6551 /////////////////////////////////////////////////////////////
6552 const Int_t kendcapcoverplatesmallholenumber = 9;
6553 Double_t endcapmotherorigin[3];
6554 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6555 + 0.5 *(fgkEndCapCoverPlateLength[3]
6556 + 2.0 * fgkEndCapCoverPlateLength[2]);
6557 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6558 - fgkEndCapCoverPlateWidth[2]
6559 - (kendcapcoverplatesmallholenumber-1)
6560 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6561 + 0.5*(fgkEndCapSideCoverLength[2]
6562 + fgkEndCapCoverPlateWidth[1]
6563 - fgkEndCapCoverPlateWidth[0])
6564 - (fgkEndCapCoverPlateWidth[1]
6565 - fgkEndCapCoverPlateWidth[0]);
6566 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6567 + 2.*fgkEndCapCoolingTubeRadiusMax
6568 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6569 + fgkEndCapSideCoverWidth[1]
6570 + fgkEndCapSideCoverThickness
6571 + fgkEndCapKaptonFoilThickness);
6572 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6573 + 2.0* fgkEndCapCoverPlateLength[2]
6574 + 2.0* fgkEndCapSideCoverThickness),
6575 0.5* (fgkEndCapSideCoverLength[2]
6576 + fgkEndCapCoverPlateWidth[1]
6577 - fgkEndCapCoverPlateWidth[0]),
6578 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6579 + fgkEndCapSideCoverWidth[1]
6580 + fgkEndCapSideCoverThickness
6581 + fgkEndCapKaptonFoilThickness),
6582 endcapmotherorigin);
6583 TGeoVolume** endcapassembly;
6584 endcapassembly = new TGeoVolume*[4];
6585 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6586 endcapmothershape,fSSDAir);
6587 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6588 endcapmothershape,fSSDAir);
6589 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6590 endcapmothershape,fSSDAir);
6591 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6592 endcapmothershape,fSSDAir);
6593 /////////////////////////////////
6594 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6595 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6596 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6597 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6598 /////////////////////////////////
6599 /////////////////////////////////////////////////////
6600 // Placing Endcap Cover Plate
6601 /////////////////////////////////////////////////////
6602 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6603 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6604 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6605 TGeoCombiTrans* endcapcoverplatecombitrans =
6606 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6607 endcapcoverplaterot);
6608 TGeoTranslation* endcapcoverplatetrans =
6609 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6610 TGeoHMatrix* endcapcoverplatematrix =
6611 new TGeoHMatrix((*endcapcoverplatetrans)
6612 * (*endcapcoverplatecombitrans));
6613 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6614 /////////////////////////////////////////////////////
6615 // Placing Endcap Side Cover
6616 /////////////////////////////////////////////////////
6617 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6618 TGeoRotation* endcapsidecoverot[2];
6619 TGeoCombiTrans* endcapsidecovercombitrans[3];
6620 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6621 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6622 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6623 - 0.5*(fgkEndCapCoverPlateWidth[0]
6624 - fgkEndCapCoverPlateWidth[2]
6625 - (kendcapcoverplatesmallholenumber-1)
6626 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6627 + 0.*fgkEndCapCoverPlateWidth[0]
6628 + fgkEndCapSideCoverLength[2],
6629 0.5*(fgkEndCapSideCoverThickness
6630 + fgkEndCapCoverPlateThickness)
6631 - 0.5*fgkEndCapCoverPlateThickness,
6632 endcapsidecoverot[0]);
6633 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6634 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6635 0.5*fgkEndCapCoverPlateThickness
6636 -fgkEndCapSideCoverWidth[1],
6637 endcapsidecoverot[1]);
6638 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6639 +fgkEndCapCoverPlateLength[3]
6640 +2.*fgkEndCapCoverPlateLength[2]
6641 +fgkEndCapSideCoverThickness,0.0,
6642 0.5*fgkEndCapCoverPlateThickness
6643 -fgkEndCapSideCoverWidth[1],
6644 endcapsidecoverot[1]);
6645 TGeoHMatrix* endcapsidecovermatrix[2];
6646 for(Int_t i=0; i<2; i++){
6647 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6648 * (*endcapsidecovercombitrans[0]));
6649 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6650 endcapsidecovermatrix[i]);
6651 }
6652 /////////////////////////////////////////////////////
6653 // Placing Endcap Cooling Tube
6654 /////////////////////////////////////////////////////
6655 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6656 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6657 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6658 TGeoCombiTrans* endcapccolingtubecombitrans
6659 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6660 + fgkEndCapCoolingTubeAxialRadius[1])
6661 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6662 - fgkEndCapCoolingTubeToCoverSide,
6663 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6664 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6665 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6666 endcapccolingtubecombitrans);
6667 /////////////////////////////////////////////////////
6668 // Placing Screws
6669 /////////////////////////////////////////////////////
6670 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6671 fgkEndCapCoverPlateScrewRadiusMin};
6672 Int_t screwcoverplatedgesnumber[2] = {20,20};
6673 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6674 fgkEndCapCoverPlateThickness
6675 + fgkEndCapCoolingTubeRadiusMax};
6676 TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6677 screwcoverplatedgesnumber,
6678 screwcoverplatesection);
6679 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6680 screwcoverplateshape,
6681 fSSDCoolingTubePhynox);
6682 screwcoverplate->SetLineColor(12);
6683 Double_t transx[4] = {0,
6684 fgkEndCapCoverPlateSmallHoleSeparation[0],
6685 fgkEndCapCoverPlateSmallHoleSeparation[0]
6686 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6687 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6688 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6689 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6690// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6691 TGeoTranslation*** endcapcoverplatescrewtrans;
6692 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6693 Int_t index = 0;
6694 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6695 endcapcoverplatescrewtrans[i] =
6696 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6697 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6698 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6699 if(index==1||index==9||index==28||index==36){
6700 endcapcoverplatescrewtrans[i][j] =
6701 new TGeoTranslation(transx[i],
6702 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6703 fgkEndCapSideCoverThickness);
6704 }
6705 else{
6706 endcapcoverplatescrewtrans[i][j] =
6707 new TGeoTranslation(transx[i],
6708 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6709 0.);
6710 }
6711 if(index!=19)
6712 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6713 endcapcoverplatescrewtrans[i][j]);
6714 }
6715 }
6716 /////////////////////////////////////////////////////
6717 // Placing Cover Plate Clips
6718 /////////////////////////////////////////////////////
6719 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6720 0.5*fgkEndCapCoverPlateClipWidth,
6721 0.5*fgkEndCapSideCoverThickness);
6722 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6723 endcapcoverplateclipshape,
6724 fSSDCoolingTubePhynox);
6725 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6726 0.5*fgkEndCapCoverPlateDownClipWidth,
6727 0.5*fgkEndCapSideCoverThickness);
6728 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6729 endcapcoverplatedownclipshape,
6730 fSSDCoolingTubePhynox);
6731 TGeoTranslation* endcapcoverplatecliptrans[4];
6732 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6733 - fgkEndCapCoverPlateLength[0]
6734 - fgkEndCapSideCoverThickness,
6735 0.0,
6736 0.5*(fgkEndCapSideCoverThickness
6737 + fgkEndCapCoverPlateThickness));
6738 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6739 - fgkEndCapCoverPlateLength[0]
6740 - fgkEndCapSideCoverThickness,
6741 (kendcapcoverplatescrewnumber[1]-1)
6742 * fgkEndCapSideCoverWidth[5],
6743 0.5*(fgkEndCapSideCoverThickness
6744 + fgkEndCapCoverPlateThickness));
6745 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6746 - fgkEndCapCoverPlateLength[0]
6747 + fgkEndCapCoverPlateLength[1]
6748 + 2.*fgkEndCapCoverPlateLength[0]
6749 - fgkEndCapCoverPlateClipLength
6750 + fgkEndCapSideCoverThickness,
6751 0.0,
6752 0.5*(fgkEndCapSideCoverThickness
6753 + fgkEndCapCoverPlateThickness));
6754 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6755 - fgkEndCapCoverPlateLength[0]
6756 + fgkEndCapCoverPlateLength[1]
6757 + 2.*fgkEndCapCoverPlateLength[0]
6758 - fgkEndCapCoverPlateClipLength
6759 + fgkEndCapSideCoverThickness,
6760 (kendcapcoverplatescrewnumber[1]-1)
6761 * fgkEndCapSideCoverWidth[5],
6762 0.5*(fgkEndCapSideCoverThickness
6763 + fgkEndCapCoverPlateThickness));
6764 endcapcoverplateclip->SetLineColor(fColorPhynox);
6765 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6766 for(Int_t i=0; i<4; i++)
6767 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6768 endcapcoverplatecliptrans[i]);
6769 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6770 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6771 - fgkEndCapCoverPlateLength[0]
6772 - fgkEndCapSideCoverThickness,
6773 0.5*(fgkEndCapCoverPlateDownClipWidth
6774 - fgkEndCapCoverPlateClipWidth),
6775 0.5*(fgkEndCapSideCoverThickness
6776 + fgkEndCapCoverPlateThickness)
6777 - fgkEndCapSideCoverWidth[1]
6778 - fgkEndCapSideCoverThickness);
6779 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6780 - fgkEndCapCoverPlateLength[0]
6781 - fgkEndCapSideCoverThickness,
6782 0.5*(fgkEndCapCoverPlateDownClipWidth
6783 - fgkEndCapCoverPlateClipWidth)
6784 + fgkEndCapSideCoverLength[2]
6785 - fgkEndCapCoverPlateDownClipWidth,
6786 0.5*(fgkEndCapSideCoverThickness
6787 + fgkEndCapCoverPlateThickness)
6788 - fgkEndCapSideCoverWidth[1]
6789 - fgkEndCapSideCoverThickness);
6790 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6791 - fgkEndCapCoverPlateLength[0]
6792 + fgkEndCapSideCoverThickness
6793 + fgkEndCapCoverPlateLength[1]
6794 + 2.0*fgkEndCapCoverPlateLength[0]
6795 - fgkEndCapCoverPlateDownClipLength,
6796 0.5*(fgkEndCapCoverPlateDownClipWidth
6797 - fgkEndCapCoverPlateClipWidth),
6798 0.5*(fgkEndCapSideCoverThickness
6799 + fgkEndCapCoverPlateThickness)
6800 - fgkEndCapSideCoverWidth[1]
6801 - fgkEndCapSideCoverThickness);
6802 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6803 - fgkEndCapCoverPlateLength[0]
6804 + fgkEndCapSideCoverThickness
6805 + fgkEndCapCoverPlateLength[1]
6806 + 2.0*fgkEndCapCoverPlateLength[0]
6807 - fgkEndCapCoverPlateDownClipLength,
6808 0.5*(fgkEndCapCoverPlateDownClipWidth
6809 - fgkEndCapCoverPlateClipWidth)
6810 + fgkEndCapSideCoverLength[2]
6811 - fgkEndCapCoverPlateDownClipWidth,
6812 0.5*(fgkEndCapSideCoverThickness
6813 + fgkEndCapCoverPlateThickness)
6814 - fgkEndCapSideCoverWidth[1]
6815 - fgkEndCapSideCoverThickness);
6816 for(Int_t i=0; i<4; i++)
6817 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6818 endcapcoverplatedowncliptrans[i]);
6819 /////////////////////////////////////////////////////
6820 // Placing Kapton Foil
6821 /////////////////////////////////////////////////////
6822 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6823 0.5*fgkEndCapKaptonFoilWidth,
6824 0.5*fgkEndCapKaptonFoilThickness);
6825 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6826 endcapkaptonfoilshape,
6827 fSSDKaptonFlexMedium);
6828 endcapkaptonfoil->SetLineColor(8);
6829 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6830 0.5*fgkEndCapKaptonFoilWidth
6831 - 0.5*fgkEndCapCoverPlateClipWidth,
6832 0.5*fgkEndCapCoverPlateThickness
6833 - 0.5*fgkEndCapKaptonFoilThickness
6834 - fgkEndCapSideCoverWidth[1]
6835 - fgkEndCapSideCoverThickness);
6836 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6837 /////////////////////////////////////////////////////////////
6838 // Placing Electronic Tubes
6839 /////////////////////////////////////////////////////////////
6840 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6841 - fgkEndCapInterfaceCardBThickness
6842 - 9.*fgkEndCapStripConnectionThickness
6843 - 8.*fgkEndCapCardElectBoardBackThickness,
6844 fgkEndCapKaptonFoilWidth
6845 - fgkEndCapInterfaceCardBThickness
6846 - 9.*fgkEndCapStripConnectionThickness
6847 - 8.*fgkEndCapCardElectBoardBackThickness
6848 - fgkEndCapInterfaceElectBoardCardBThickness};
6849 TGeoVolume* endcapeffectivecables[2];
6850 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6851 fgkEndCapEffectiveCableRadiusMax,
6852 endcapeffectivecableswidth[0],
6853 10,"EndCapEffectiveCables1");
6854 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6855 fgkEndCapEffectiveCableRadiusMax,
6856 endcapeffectivecableswidth[1],
6857 25,"EndCapEffectiveCables2");
6858 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6859 TGeoTranslation* endcapeffectivecablestrans[2];
6860 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6861 - 0.5*endcapeffectivecableswidth[0]
6862 - 0.5*(fgkEndCapCoverPlateWidth[0]
6863 - fgkEndCapCoverPlateWidth[2]
6864 - (kendcapcoverplatesmallholenumber-1)
6865 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6866 + fgkEndCapSideCoverLength[2],
6867 - 0.5*fgkEndCapCoverPlateThickness
6868 - (fgkEndCapCardElectBoardBackWidth[0]
6869 - fgkEndCapInterfaceCardBWidth[0]
6870 - fgkEndCapInterfaceCardBWidth[1]));
6871 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6872 - 0.5*endcapeffectivecableswidth[1]
6873 - 0.5*(fgkEndCapCoverPlateWidth[0]
6874 - fgkEndCapCoverPlateWidth[2]
6875 - (kendcapcoverplatesmallholenumber-1)
6876 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6877 + fgkEndCapSideCoverLength[2],
6878 - 0.5*fgkEndCapCoverPlateThickness
6879 - (fgkEndCapCardElectBoardBackWidth[0]
6880 - fgkEndCapInterfaceCardBWidth[0])
6881 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6882 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6883 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6884 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6885 *endcapeffectivecablesrot);
6886 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6887 *endcapeffectivecablesrot);
6888 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6889 endcapeffectivecablescombitrans[0]);
6890 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6891 endcapeffectivecablescombitrans[1]);
6892 /////////////////////////////////////////////////////////////
6893 // Placing End Cap Cards
6894 /////////////////////////////////////////////////////////////
6895 TGeoVolume** endcapcards = GetEndCapCards();
6896 TGeoRotation* endcapcardsrot[2];
6897 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6898 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6899 TGeoTranslation* endcapcardstrans[2];
6900 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6901 - fgkEndCapCardElectBoardBackLength[0]));
6902 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6903 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6904 TGeoHMatrix* endcapcardsmatrix[2];
6905 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6906 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6907 - fgkEndCapCardJMDConnectorLength[0]
6908 - fgkEndCapInterfaceCardBThickness
6909 - 9.*fgkEndCapStripConnectionThickness
6910 - 8.*fgkEndCapCardElectBoardBackThickness;
6911 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6912 - fgkEndCapCoverPlateLength[0]
6913 + 0.5 * (fgkEndCapCoverPlateLength[3]
6914 + 2.0 * fgkEndCapCoverPlateLength[2]),
6915 - stiffenertransx-fgkEndCapStiffenerWidth
6916 - fgkEndCapCardJMDConnectorLength[0]
6917 - fgkEndCapInterfaceCardBThickness
6918 - 2.0 * fgkEndCapStripConnectionThickness
6919 - 1.5 * fgkEndCapInterfaceCardBThickness
6920 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6921 - fgkEndCapCoverPlateWidth[2]
6922 - (kendcapcoverplatesmallholenumber-1)
6923 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6924 + fgkEndCapKaptonFoilWidth,
6925 0.5*fgkEndCapCoverPlateThickness
6926 - fgkEndCapSideCoverWidth[1]);
6927 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6928 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6929 /////////////////////////////////////////////////////////////
6930 // Deallocating memory
6931 /////////////////////////////////////////////////////////////
6932 delete endcapcoverplaterot;
6933 delete endcapcoverplatecombitrans;
6934 delete endcapcoverplatetrans;
6935 for(Int_t i=0; i<3; i++){
6936 delete endcapsidecovercombitrans[i];
6937 if(i<2) delete endcapsidecoverot[i];
6938 }
6939 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6940 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6941 delete endcapcardsmatrix[0];
6942 return endcapassembly;
6943 }
6944 ////////////////////////////////////////////////////////////////////////////////
6945 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6946 Double_t radiusmax,
6947 Double_t width,
6948 Int_t ncables,
6949 char* volname){
6950 /////////////////////////////////////////////////////////////
6951 // Generating EndCap High Voltage Tubes
6952 /////////////////////////////////////////////////////////////
6953 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6954 Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.)
6955 + TMath::Power(radiusmax,2.)
6956 - TMath::Power(radiusmin,2.));
6957 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6958 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6959 effectiveouteradius,0.5*width);
6960 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6961 effectiveinnertubeshape,
6962 fSSDStiffenerConnectorMedium);
6963 effectiveinnertube->SetLineColor(41);
6964 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6965 effectiveoutertubeshape,
6966 fSSDKaptonChipCableMedium);
6967 effectiveoutertube->SetLineColor(39);
6968 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6969 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6970 effectivemothertube->AddNode(effectiveinnertube,1);
6971 effectivemothertube->AddNode(effectiveoutertube,1);
6972 return effectivemothertube;
6973 }
6974 ////////////////////////////////////////////////////////////////////////////////
6975 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6976 /////////////////////////////////////////////////////////////
6977 // Generating EndCap Support Layer 5 and Layer 6
6978 /////////////////////////////////////////////////////////////
6979 const Int_t knedges = 5;
6980 ///////////////////////////////////////////////
6981 // Setting the vertices for TGeoXtru Up Volume
6982 ///////////////////////////////////////////////
6983 const Int_t klayernumber = 2;
6984 Double_t xupvertex[klayernumber][knedges+3];
6985 Double_t yupvertex[klayernumber][knedges+3];
6986 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6987 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6988 Double_t middlepsi[klayernumber] = {0.0,0.0};
6989 for(Int_t i=0; i<klayernumber; i++){
6990 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6991 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6992 xupvertex[i][2] = -xupvertex[i][1];
6993 xupvertex[i][3] = -xupvertex[i][0];
6994
6995 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6996 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6997 yupvertex[i][2] = yupvertex[i][1];
6998 yupvertex[i][3] = yupvertex[i][0];
6999
7000 middledgeangle[i] = upedgeangle[i]/knedges;
7001 middlepsi[i] = 90.0-0.5*upedgeangle[i];
7002 for(Int_t j=1; j<knedges; j++){
7003 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
7004 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
7005 }
7006 }
7007 ////////////////////////////////////
7008 // Generating Up TGeoXtru
7009 ////////////////////////////////////
7010 TGeoXtru* upendcapsupportshape[klayernumber];
7011 TGeoVolume* upendcapsupport[klayernumber];
7012 char upendcapsupportname[30];
7013 for(Int_t i=0; i<klayernumber; i++){
7014 upendcapsupportshape[i] = new TGeoXtru(2);
7015 sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
7016 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
7017 upendcapsupportshape[i]->DefineSection(0,0.);
7018 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
7019 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
7020 fSSDCoolingTubePhynox);
7021// upendcapsupport[i]->SetLineColor(fColorPhynox);
7022 upendcapsupport[i]->SetLineColor(5);
7023 }
7024 ///////////////////////////////////////////////
7025 // Setting the vertices for TGeoXtru Down Volume
7026 ///////////////////////////////////////////////
7027 Double_t xdownvertex[klayernumber][2*(knedges+1)];
7028 Double_t ydownvertex[klayernumber][2*(knedges+1)];
7029 for(Int_t i=0; i<klayernumber; i++){
7030 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
7031 xdownvertex[i][1] = xupvertex[i][0];
7032 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
7033 ydownvertex[i][1] = yupvertex[i][0];
7034 for(Int_t j=0; j<knedges; j++){
7035 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
7036 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
7037 }
7038 for(Int_t j=0; j<knedges; j++){
7039 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
7040 * CosD(middlepsi[i]+j*middledgeangle[i]);
7041 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
7042 * SinD(middlepsi[i]+j*middledgeangle[i]);
7043 }
7044 }
7045 ////////////////////////////////////
7046 // Generating Down TGeoXtru
7047 ////////////////////////////////////
7048 TGeoXtru* downendcapsupportshape[klayernumber];
7049 TGeoVolume* downendcapsupport[klayernumber];
7050 char downendcapsupportname[30];
7051 for(Int_t i=0; i<klayernumber; i++){
7052 downendcapsupportshape[i] = new TGeoXtru(2);
7053 sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
7054 downendcapsupportshape[i] = new TGeoXtru(2);
7055 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
7056 if(i==0){
7057 downendcapsupportshape[i]->DefineSection(0,0.);
7058 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
7059 }
7060 else{
7061 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
7062 - fgkEndCapSupportLowWidth[i]);
7063 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
7064 }
7065 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
7066 downendcapsupportshape[i],fSSDCoolingTubePhynox);
7067// downendcapsupport[i]->SetLineColor(fColorPhynox);
7068 downendcapsupport[i]->SetLineColor(5);
7069 }
7070 ///////////////////////////////////////////////
7071 // Setting TGeoPgon Volume
7072 ///////////////////////////////////////////////
7073 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
7074 fgkSSDLay6LadderNumber};
7075 TGeoPgon* endcapsupportmothershape[klayernumber];
7076 TGeoVolume** endcapsupportmother;
7077 endcapsupportmother = new TGeoVolume*[klayernumber];
7078 char endcapsupportmothername[30];
7079 for(Int_t i=0; i<klayernumber; i++){
7080 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7081 sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
7082 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
7083 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
7084 ydownvertex[i][0],yupvertex[i][1]);
7085 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
7086 fSSDCoolingTubePhynox);
7087 }
7088 ////////////////////////////////////
7089 TGeoRotation** endcapsupportrot[klayernumber];
7090 for(Int_t i=0; i<2; i++){
7091 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
7092 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7093 endcapsupportrot[i][j] = new TGeoRotation();
7094 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
7095 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
7096 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
7097 }
7098 }
7099 return endcapsupportmother;
7100 }
7101 ////////////////////////////////////////////////////////////////////////////////
7102 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
7103 /////////////////////////////////////////////////////////////
7104 // Setting End Cap Support Layer 5 and 6.
7105 /////////////////////////////////////////////////////////////
7106 const Int_t kendcapcoverplatesmallholenumber = 9;
7107 const Int_t klayernumber = 2;
7108 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
7109 fgkSSDLay6LadderNumber};
7110 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
7111 360.0/kssdlayladdernumber[1]};
7112 TGeoVolume** endcapsupport = EndCapSupport();
7113 TGeoVolume** endcapassembly = GetEndCapAssembly();
7114 TGeoPgon* endcapsupportshape[klayernumber];
7115 Double_t* radiusmin[klayernumber];
7116 Double_t* radiusmax[klayernumber];
7117 for(Int_t i=0; i<klayernumber; i++){
7118 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
7119 radiusmin[i] = endcapsupportshape[i]->GetRmin();
7120 radiusmax[i] = endcapsupportshape[i]->GetRmax();
7121 }
7122 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
7123 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
7124 endcapassemblyshape->GetDY(),
7125 endcapassemblyshape->GetDZ()};
7126 ///////////////////////////////////////////////
7127 // Setting TGeoPgon Volume for Mother Container
7128 ///////////////////////////////////////////////
7129 TGeoPgon* endcapsupportsystemshape[klayernumber];
7130 char endcapsupportsystemothername[30];
7131 for(Int_t i=0; i<klayernumber; i++){
7132 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7133 sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
7134 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
7135 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
7136 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7137 +2.*endcapassemblycenter[2])
7138 /CosD(0.5*upedgeangle[i]));
7139 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7140 -(fgkEndCapCoverPlateWidth[1]
7141 - fgkEndCapCoverPlateWidth[0]),
7142 *radiusmin[i],
7143 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7144 +2.*endcapassemblycenter[2])
7145 /CosD(0.5*upedgeangle[i]));
7146 }
7147 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7148 endcapsupportsystemshape[0],fSSDAir);
7149 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7150 endcapsupportsystemshape[0],fSSDAir);
7151 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7152 endcapsupportsystemshape[1],fSSDAir);
7153 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7154 endcapsupportsystemshape[1],fSSDAir);
7155 ///////////////////////////////////////////////
7156 TGeoTranslation* endcapassemblytrans[klayernumber];
7157 for(Int_t i=0; i<klayernumber; i++)
7158 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7159 - fgkEndCapSideCoverThickness
7160 + endcapassemblycenter[0],
7161 - 0.5*fgkEndCapCoverPlateThickness
7162 - 2.0*fgkEndCapCoolingTubeRadiusMax
7163 + 2.0*endcapassemblycenter[2]
7164 + 0.5*fgkEndCapSupportLength[i]
7165 / TanD(0.5*upedgeangle[i]),
7166 0.5*(fgkEndCapCoverPlateWidth[0]
7167 - fgkEndCapCoverPlateWidth[2]
7168 - (kendcapcoverplatesmallholenumber-1)
7169 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
7170 TGeoRotation** endcapassemblyrot[klayernumber];
7171 TGeoHMatrix** endcapassemblymatrix[klayernumber];
7172 for(Int_t i=0; i<klayernumber; i++){
7173 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7174 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7175 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7176 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7177 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7178 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7179 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7180 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7181 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7182 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7183 }
7184 }
7185 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7186 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7187 for(Int_t i=0; i<2*klayernumber; i++){
7188 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7189 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7190 endcapassemblymatrix[1][j+2]);
7191 }
7192 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7193 }
7194 /////////////////////////////////////////////////////////////
7195 // Deallocating memory
7196 /////////////////////////////////////////////////////////////
7197 for(Int_t i=0; i<klayernumber; i++){
7198 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7199 delete endcapassemblyrot[i][j];
7200 }
7201 delete endcapassemblyrot[i];
7202 delete endcapassemblymatrix[i][0];
7203 delete endcapassemblymatrix[i][1];
7204 }
7205 /////////////////////////////////////////////////////////////
7206 }
7207 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7208 /////////////////////////////////////////////////////////////
7209 // Setting End Cap Support + End Cap Assembly of Layer 5.
7210 /////////////////////////////////////////////////////////////
7211 if (! moth) {
7212 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, mother is null!\n");
7213 return;
7214 };
7215 if(!fgkEndCapSupportSystem[0]) SetEndCapSupportAssembly();
7216 if(!fgkEndCapSupportSystem[1]) SetEndCapSupportAssembly();
7217 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7218 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7219 fgkEndCapSupportCenterLay5ITSPosition
7220 + fgkEndCapSupportCenterLay5Position
7221 - fgkEndCapSideCoverLength[2]);
7222 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7223 fgkEndCapSideCoverLength[2]
7224 - fgkEndCapSupportCenterLay5Position
7225 - fgkEndCapSupportCenterLay5ITSPosition);
7226 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7227 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7228 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7229 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7230 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7231 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7232 /////////////////////////////////////////////////////////////
7233 // Deallocating memory
7234 /////////////////////////////////////////////////////////////
7235 delete endcapsupportsystemrot;
7236 delete endcapsupportsystemITSCentertrans[1];
7237 }
7238 /////////////////////////////////////////////////////////////
7239 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7240 /////////////////////////////////////////////////////////////
7241 // Setting End Cap Support + End Cap Assembly of Layer 6.
7242 /////////////////////////////////////////////////////////////
7243 if (! moth) {
7244 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
7245 return;
7246 };
7247 if(!fgkEndCapSupportSystem[2]) SetEndCapSupportAssembly();
7248 if(!fgkEndCapSupportSystem[3]) SetEndCapSupportAssembly();
7249 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7250 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7251 fgkEndCapSupportCenterLay6ITSPosition
7252 + fgkEndCapSupportCenterLay6Position
7253 - fgkEndCapSideCoverLength[2]);
7254 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7255 fgkEndCapSideCoverLength[2]
7256 - fgkEndCapSupportCenterLay6Position
7257 - fgkEndCapSupportCenterLay6ITSPosition);
7258 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7259 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7260 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7261 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7262 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7263 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7264 /////////////////////////////////////////////////////////////
7265 // Deallocating memory
7266 /////////////////////////////////////////////////////////////
7267 delete endcapsupportsystemrot;
7268 delete endcapsupportsystemITSCentertrans[1];
7269 }
7270 ////////////////////////////////////////////////////////////////////////////////
7271 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7272 /////////////////////////////////////////////////////////////
7273 // Setting Ladder Support of Layer 5.
7274 /////////////////////////////////////////////////////////////
7275 if (! moth) {
7276 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
7277 return;
7278 };
7279 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7280 fMotherVol = moth;
7281 TGeoTranslation* centerITSRingSupportLay5trans[2];
7282 for(Int_t i=0; i<2; i++){
7283 centerITSRingSupportLay5trans[i] =
7284 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7285 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7286 }
7287 }
7288 ////////////////////////////////////////////////////////////////////////////////
7289 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7290 /////////////////////////////////////////////////////////////
7291 // Setting Ladder Support of Layer 6.
7292 /////////////////////////////////////////////////////////////
7293 if (! moth) {
7294 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
7295 return;
7296 };
7297 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7298 fMotherVol = moth;
7299 TGeoTranslation* centerITSRingSupportLay6trans[2];
7300 for(Int_t i=0; i<2; i++){
7301 centerITSRingSupportLay6trans[i] =
7302 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7303 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7304 }
7305 }
7306 ////////////////////////////////////////////////////////////////////////////////
d7599219 7307TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
44285dfa 7308 Double_t height, char* shapename, Int_t isign) const{
7309 /////////////////////////////////////////////////////////////
7310 // Method generating an Arb shape
7311 /////////////////////////////////////////////////////////////
7312 const Int_t kvertexnumber = 8;
7313 const Int_t ktransvectnumber = 2;
7314 TVector3* vertex[kvertexnumber];
7315 TVector3* transvector[2];
7316 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
7317 /////////////////////////////////////////////////////////////
d7599219 7318 //Setting the vertices for TGeoArb8
44285dfa 7319 /////////////////////////////////////////////////////////////
7320 vertex[0] = new TVector3(*vertexpos[0]);
7321 vertex[1] = new TVector3(*vertexpos[1]);
7322 vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
7323 vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
7324 vertex[4] = new TVector3(*vertexpos[2]);
7325 vertex[5] = new TVector3(*vertexpos[3]);
7326 vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
7327 vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
7328 /////////////////////////////////////////////////////////////
7329 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
7330 for(Int_t i = 0; i<kvertexnumber;i++)
7331 arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
bf210566 7332 /////////////////////////////////////////////////////////////
7333 // Deallocating memory
7334 /////////////////////////////////////////////////////////////
7335 for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
7336 for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
7337 /////////////////////////////////////////////////////////////
44285dfa 7338 return arbshape;
d7599219 7339}
bf210566 7340///////////////////////////////////////////////////////////////////////////////
7341TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
7342 Double_t rmax, Int_t nedges, Double_t height){
7343 /////////////////////////////////////////////////////////////
7344 // Method generating Arc shape
7345 /////////////////////////////////////////////////////////////
7346 const Int_t kvertexnumber = 2*nedges+2;
7347 TGeoXtru* arcshape = new TGeoXtru(2);
7348 TVector3** vertexposition[2];
7349 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
7350 Double_t angle = 0.;
7351 for(Int_t i=0; i<nedges+1; i++){
7352 angle = 90.+0.5*phi-i*(phi/nedges);
7353 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
7354 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
7355 }
7356 Double_t *xvertexpoints = new Double_t[kvertexnumber];
7357 Double_t *yvertexpoints = new Double_t[kvertexnumber];
7358 for(Int_t i=0; i<kvertexnumber; i++){
7359 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
7360 yvertexpoints[i] = vertexposition[0][i]->Y();
7361 }
7362 else if(i>=1&&i<nedges+2)
7363 {
7364 xvertexpoints[i] = vertexposition[1][i-1]->X();
7365 yvertexpoints[i] = vertexposition[1][i-1]->Y();
7366 }
7367 else
7368 {
7369 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
7370 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
7371 }
7372 }
7373 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
7374 arcshape->DefineSection(0,-0.5*height);
7375 arcshape->DefineSection(1,0.5*height);
44285dfa 7376 /////////////////////////////////////////////////////////////
bf210566 7377 // Deallocating memory
44285dfa 7378 /////////////////////////////////////////////////////////////
bf210566 7379 for(Int_t i=0; i<2; i++){
7380 for(Int_t j=0; j<nedges+1; j++)
7381 delete vertexposition[i][j];
7382 delete [] vertexposition[i];
7383 }
7384 delete [] xvertexpoints;
7385 delete [] yvertexpoints;
7386 /////////////////////////////////////////////////////////////
7387 return arcshape;
d7599219 7388}
7389////////////////////////////////////////////////////////////////////////////////
9b0c60ab 7390TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
7391 ///////////////////////////////////////////////////////////////////////
7392 // Method Generating the Screw Shape
7393 // radius[0]: outer radius
7394 // radius[1]: inner radius
7395 // edgesnumber[0]: outer number of edges
7396 // edgesnumber[1]: inner number of edges
7397 // section[0]: lower section position
7398 // section[1]: higher section position
7399 ///////////////////////////////////////////////////////////////////////
7400 Double_t outradius = radius[0];
7401 Double_t inradius = radius[1];
7402 Int_t outvertexnumber = edgesnumber[0];
7403 Int_t invertexnumber = edgesnumber[1];
7404 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7405 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7406 for(Int_t i=0; i<outvertexnumber+1; i++){
7407 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
7408 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
7409 }
7410 for(Int_t i=0; i<invertexnumber+1; i++){
7411 xscrewvertex[outvertexnumber+i+1] = inradius*CosD(90.-i*360./invertexnumber);
7412 yscrewvertex[outvertexnumber+i+1] = inradius*SinD(90.-i*360./invertexnumber);
7413 }
7414 TGeoXtru* screwshape = new TGeoXtru(2);
7415 screwshape->DefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex);
7416 screwshape->DefineSection(0,section[0]);
7417 screwshape->DefineSection(1,section[1]);
7418 delete [] xscrewvertex;
7419 delete [] yscrewvertex;
7420 return screwshape;
7421}
7422////////////////////////////////////////////////////////////////////////////////
7423TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
7424 ///////////////////////////////////////////////////////////////////////
7425 // Method Generating the Hole Shape
7426 // radius of the Hole
7427 // nedges: number of edges to approximate the circle
7428 ///////////////////////////////////////////////////////////////////////
7429 Int_t vertexnumber = nedges+6;
7430 Double_t* xholevertex = new Double_t[vertexnumber];
7431 Double_t* yholevertex = new Double_t[vertexnumber];
7432 xholevertex[0] = radius;
7433 xholevertex[1] = xholevertex[0];
7434 xholevertex[2] = -xholevertex[1];
7435 xholevertex[3] = xholevertex[2];
7436 xholevertex[4] = xholevertex[0];
7437 yholevertex[0] = 0.;
7438 yholevertex[1] = -radius;
7439 yholevertex[2] = yholevertex[1];
7440 yholevertex[3] = -yholevertex[1];
7441 yholevertex[4] = yholevertex[3];
7442 for(Int_t i=0; i<nedges+1; i++){
7443 xholevertex[i+5] = radius*CosD(i*360./nedges);
7444 yholevertex[i+5] = radius*SinD(i*360./nedges);
7445 }
7446 TGeoXtru* holeshape = new TGeoXtru(2);
7447 holeshape->DefinePolygon(vertexnumber,xholevertex,yholevertex);
7448 holeshape->DefineSection(0,section[0]);
7449 holeshape->DefineSection(1,section[1]);
7450 delete [] xholevertex;
7451 delete [] yholevertex;
7452 return holeshape;
7453}
7454////////////////////////////////////////////////////////////////////////////////
44285dfa 7455TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
7456 /////////////////////////////////////////////////////////////
7457 // Given an axis specified by param, it gives the reflection of the point
7458 // respect to the axis
7459 /////////////////////////////////////////////////////////////
7460 TVector3* n = new TVector3(param[0],param[1],param[2]);
7461 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
7462 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 7463 /////////////////////////////////////////////////////////////
7464 // Deallocating memory
7465 /////////////////////////////////////////////////////////////
7466 delete n;
7467 /////////////////////////////////////////////////////////////
44285dfa 7468 return reflectedvector;
d7599219 7469}
7470////////////////////////////////////////////////////////////////////////////////
bf210566 7471TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
d7599219 7472 Double_t dx,
7473 Double_t dy,
7474 Double_t dz) const{
44285dfa 7475 /////////////////////////////////////////////////////////////
d7599219 7476 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 7477 /////////////////////////////////////////////////////////////
bf210566 7478 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
7479 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 7480 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 7481 hmatrix->SetTranslation(newvect);
7482 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
7483 delete hmatrix;
7484 return matrix;
d7599219 7485}
7486////////////////////////////////////////////////////////////////////////////////
d7599219 7487TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 7488 /////////////////////////////////////////////////////////////
7489 // Method returning the Medium type
7490 /////////////////////////////////////////////////////////////
d7599219 7491 char ch[30];
7492 sprintf(ch, "ITS_%s",mediumName);
7493 TGeoMedium* medium = gGeoManager->GetMedium(ch);
7494 if (! medium)
7495 printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
7496 return medium;
7497}
7498////////////////////////////////////////////////////////////////////////////////
d7599219 7499void AliITSv11GeometrySSD::CreateMaterials(){
7500///////////////////////////////////
7501// This part has to be modified
7502///////////////////////////////////
7503 ///////////////////////////////////
7504 // Silicon for Sensor
7505 ///////////////////////////////////
bf210566 7506 fSSDSensorMedium = GetMedium("SI$");
d7599219 7507 ///////////////////////////////////
7508 // Silicon Mixture for Sensor
7509 ///////////////////////////////////
44285dfa 7510 fSSDChipMedium = GetMedium("SPD SI CHIP$");
7511 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 7512 ///////////////////////////////////
7513 // Stiffener Components Materials
7514 ///////////////////////////////////
bf210566 7515 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 7516 ///////////////////////////
7517 // Stiffener Connectors
7518 ///////////////////////////
bf210566 7519 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 7520 ////////////////////////////////
7521 // Stiffener 0603-1812 Capacitor
7522 ////////////////////////////////
bf210566 7523 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
7524 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
d7599219 7525 ///////////////////////////
7526 // Stiffener Hybrid Wire
7527 ///////////////////////////
bf210566 7528 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 7529 ///////////////////////////
7530 // Al for Cooling Block
7531 ///////////////////////////
bf210566 7532 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 7533 //////////////////////////////////////////////////////
7534 // Kapton and Al for Chip Cable Flex and Ladder Cables
7535 //////////////////////////////////////////////////////
bf210566 7536 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7537 fSSDAlTraceChipCableMedium = GetMedium("AL$");
7538 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
7539 fSSDAlTraceFlexMedium = GetMedium("AL$");
7540 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7541 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 7542 /////////////////////////////////////////////////////////////////
7543 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
7544 //////////////////////////////////////////////////////////////////
44285dfa 7545 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 7546 /////////////////////////////////////////////////////////////////
7547 // G10 for Detector Leg, TubeHolder
7548 //////////////////////////////////////////////////////////////////
44285dfa 7549 fSSDTubeHolderMedium = GetMedium("G10FR4$");
7550 fSSDSensorSupportMedium = GetMedium("G10FR4$");
7551 fSSDMountingBlockMedium = GetMedium("G10FR4$");
7552 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 7553 /////////////////////////////////////////////////////////////////
7554 // Water and Phynox for Cooling Tube
7555 //////////////////////////////////////////////////////////////////
bf210566 7556 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 7557 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 7558 /////////////////////////////////////////////////////////////////////
9b0c60ab 7559 // Material for Support Rings
7560 /////////////////////////////////////////////////////////////////////
7561 fSSDSupportRingAl = GetMedium("AL$");
7562 /////////////////////////////////////////////////////////////////////
bf210566 7563 fSSDAir = GetMedium("SDD AIR$");
7564 fCreateMaterials = kTRUE;
d7599219 7565}
7566/////////////////////////////////////////////////////////////////////