]> 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
fixed a bug in AliTRDchamberTimeBin::GetClusters()
[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySSD.cxx
CommitLineData
d7599219 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
9b0c60ab 16/* $Id$ */
d7599219 17
18//*************************************************************************
19// SSD geometry, based on ROOT geometrical modeler
20//
21// Enrico Cattaruzza ecattar@ts.infn.it
22//*************************************************************************
23#include "TMath.h"
24#include "TGeoVolume.h"
d7599219 25#include "TGeoMatrix.h"
26#include <TGeoManager.h>
d7599219 27#include "TVector3.h"
28#include "TGeoArb8.h"
29#include "TList.h"
30#include "TGeoMatrix.h"
31#include "TGeoCompositeShape.h"
32#include "TGeoTube.h"
33#include "TGeoBBox.h"
bf210566 34#include "TGeoXtru.h"
9b0c60ab 35#include "TGeoTorus.h"
36#include "TGeoPgon.h"
37#include "TRotation.h"
44285dfa 38#include "AliITSv11GeometrySSD.h"
d7599219 39/////////////////////////////////////////////////////////////////////////////////
bf210566 40// Names of the Sensitive Volumes of Layer 5 and Layer 6
41/////////////////////////////////////////////////////////////////////////////////
02d4acf9 42const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5";
43const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6";
bf210566 44/////////////////////////////////////////////////////////////////////////////////
d7599219 45//Parameters for SSD Geometry
46/////////////////////////////////////////////////////////////////////////////////
e21cdd03 47// Variable for Vertical Disalignement of Modules
48/////////////////////////////////////////////////////////////////////////////////
02d4acf9 49const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
e21cdd03 50/////////////////////////////////////////////////////////////////////////////////
d7599219 51// Layer5 (lengths are in mm and angles in degrees)
52/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 53const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
d7599219 54const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
55const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
9acf2ecc 56const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
57const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
58const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
d7599219 59/////////////////////////////////////////////////////////////////////////////////
60// Layer6 (lengths are in mm and angles in degrees)
61/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 62const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
d7599219 63const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
64const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
9acf2ecc 65const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
66const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
67const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
d7599219 68/////////////////////////////////////////////////////////////////////////////////
69// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
70/////////////////////////////////////////////////////////////////////////////////
71const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
9acf2ecc 72const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
73const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
74const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
75const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
bf210566 76const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
77const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
9acf2ecc 78const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
d7599219 79/////////////////////////////////////////////////////////////////////////////////
80// Stiffener (lengths are in mm and angles in degrees)
81/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 82const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
83const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
bf210566 84//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 3.315;
9acf2ecc 85const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm;
86const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
bf210566 87const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
9acf2ecc 88const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
89const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
90const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
91const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
bf210566 92const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 0.700*fgkmm; // multiplied by 0.5
9acf2ecc 93const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
94const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
bf210566 95const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] =
96 {44.32*fgkmm, 0.33*fgkmm};
97const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
98const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
99const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
d7599219 100const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight =
bf210566 101 0.25*fgkSSDStiffenerHeight;
102const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
103const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
d7599219 104/////////////////////////////////////////////////////////////////////////////////
105// Cooling Block (lengths are in mm and angles in degrees)
106/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 107const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
108const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
bf210566 109const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
110 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
d7599219 111const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
bf210566 112 {1.000*fgkmm, 0.120*fgkmm};
d7599219 113const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
bf210566 114 {1.900*fgkmm, 0.400*fgkmm};
d7599219 115const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
9acf2ecc 116 1.500*fgkmm;
d7599219 117const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
9acf2ecc 118 0.300*fgkmm;
d7599219 119/////////////////////////////////////////////////////////////////////////////////
120// SSD Sensor (lengths are in mm and angles in degrees)
121/////////////////////////////////////////////////////////////////////////////////
122const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
bf210566 123 "SSDSensorSensitiveVol";
9acf2ecc 124const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
125const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
126const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
d7599219 127const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
9acf2ecc 128 fgkSSDSensorLength-39.1*fgkmm;
bf210566 129const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
130const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
d7599219 131/////////////////////////////////////////////////////////////////////////////////
132// Flex (lengths are in mm and angles in degrees)
133/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 134const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
d7599219 135const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
bf210566 136 {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
137 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
138 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
139 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
140 - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
d7599219 141const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
bf210566 142 { 9.340*fgkmm, 5.380*fgkmm};
d7599219 143const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
bf210566 144 { 0.030*fgkmm, 0.020*fgkmm};
d7599219 145const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
9acf2ecc 146const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
147const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
d7599219 148const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
bf210566 149 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
d7599219 150const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
bf210566 151 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
d7599219 152/////////////////////////////////////////////////////////////////////////////////
153// SSD Ladder Cable (lengths are in mm and angles in degrees)
154/////////////////////////////////////////////////////////////////////////////////
bf210566 155const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
d7599219 156/////////////////////////////////////////////////////////////////////////////////
157// SSD Module (lengths are in mm and angles in degrees)
158/////////////////////////////////////////////////////////////////////////////////
159const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
bf210566 160 { 1.000*fgkmm, 3.900*fgkmm};
d7599219 161const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
9acf2ecc 162 45.600*fgkmm;
d7599219 163const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
9acf2ecc 164 5.075*fgkmm;
d7599219 165/////////////////////////////////////////////////////////////////////////////////
166// Sensor Support (lengths are in mm and angles in degrees)
167/////////////////////////////////////////////////////////////////////////////////
bf210566 168const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
169 5.800*fgkmm;
d7599219 170const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
bf210566 171 2.000*fgkmm;
d7599219 172const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
bf210566 173 { 4.620*fgkmm, 5.180*fgkmm};
174const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
175 { 0.450*fgkmm, 0.450*fgkmm};
176const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
177 = 0.5 * (fgkSSDModuleSensorSupportDistance
178 + fgkSSDSensorSideSupportThickness[0])
179 - fgkSSDSensorSideSupportLength;
d7599219 180const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
bf210566 181 5.250*fgkmm;
d7599219 182const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
bf210566 183 1.680*fgkmm;
184const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
185 = {fgkSSDSensorSideSupportHeight[0]
186 + fgkSSDSensorSideSupportThickness[0],
187 fgkSSDSensorSideSupportHeight[1]
188 + fgkSSDSensorSideSupportThickness[1]};
189const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
190 = {fgkSSDSensorSideSupportThickness[0],
191 fgkSSDSensorSideSupportThickness[1]};
d7599219 192const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
bf210566 193 19.000*fgkmm;
d7599219 194/////////////////////////////////////////////////////////////////////////////////
195// Chip Cables (lengths are in mm and angles in degrees)
196/////////////////////////////////////////////////////////////////////////////////
197const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
bf210566 198 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
d7599219 199const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
bf210566 200 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
201 - (fgkSSDSensorSideSupportHeight[1]
202 - fgkSSDSensorSideSupportHeight[0])
203 - fgkSSDCoolingBlockHoleCenter
204 - fgkSSDStiffenerHeight
205 - fgkSSDChipHeight-fgkSSDSensorHeight,
206 fgkSSDModuleCoolingBlockToSensor
207 - fgkSSDCoolingBlockHoleCenter
208 - fgkSSDStiffenerHeight
209 - fgkSSDChipHeight-fgkSSDSensorHeight};
d7599219 210const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
bf210566 211 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
d7599219 212/////////////////////////////////////////////////////////////////////////////////
213// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
214/////////////////////////////////////////////////////////////////////////////////
215const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
bf210566 216 3.820*fgkmm;
217//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
218// 3.780;
d7599219 219const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
bf210566 220 fgkSSDSensorLength-fgkSSDSensorOverlap;
d7599219 221const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
bf210566 222 { 0.86*fgkmm, 0.30*fgkmm};
d7599219 223const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
bf210566 224 { 30.00, 90.00};
d7599219 225const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
bf210566 226 1.78*fgkmm;
d7599219 227/////////////////////////////////////////////////////////////////////////////////
228//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
229/////////////////////////////////////////////////////////////////////////////////
bf210566 230const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
231 = fgkSSDModuleSensorSupportDistance
232 - 2. * fgkCarbonFiberJunctionToSensorSupport;
233const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
d7599219 234const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
bf210566 235 { 0.751*fgkmm, 0.482*fgkmm};
236const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
237 1.630*fgkmm;
238const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
239const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
240 = fgkCarbonFiberTriangleLength
241 - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
242 / TMath::Cos(fgkCarbonFiberTriangleAngle
243 * TMath::DegToRad());
244const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
245 = 0.5*(fgkCarbonFiberJunctionWidth
246 - fgkCarbonFiberSupportWidth)
247 - fgkCarbonFiberSupportTopEdgeDist[0]
248 - fgkCarbonFiberSupportWidth;
d7599219 249/////////////////////////////////////////////////////////////////////////////////
250// Carbon Fiber Lower Support Parameters (lengths are in mm)
251/////////////////////////////////////////////////////////////////////////////////
252const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
9acf2ecc 253 = 0.950*fgkmm;
d7599219 254const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
9acf2ecc 255 = 1.600*fgkmm;
d7599219 256const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
9acf2ecc 257 = 0.830*fgkmm;
d7599219 258const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
259 = 0.5*fgkCarbonFiberSupportWidth;
260const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
bf210566 261 = fgkCarbonFiberJunctionWidth
262 - 2. * (fgkCarbonFiberLowerSupportWidth
263 + fgkCarbonFiberLowerSupportVolumeSeparation);
d7599219 264const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
bf210566 265 = {fgkCarbonFiberLowerSupportWidth
266 + fgkCarbonFiberLowerSupportVolumeSeparation,
267 fgkCarbonFiberLowerSupportWidth
268 + fgkCarbonFiberLowerSupportVolumeSeparation
269 + fgkCarbonFiberLowerSupportTransverseWidth};
d7599219 270/////////////////////////////////////////////////////////////////////////////////
271// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
272/////////////////////////////////////////////////////////////////////////////////
273const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
bf210566 274 {0.5 * (fgkSSDLay5LadderLength
275 - fgkSSDLay5SensorsNumber
276 * fgkCarbonFiberJunctionWidth
277 - fgkCarbonFiberLowerSupportWidth),
278 0.5 * (fgkSSDLay5LadderLength
279 - fgkSSDLay5SensorsNumber
280 * fgkCarbonFiberJunctionWidth
281 + fgkCarbonFiberLowerSupportWidth)};
d7599219 282const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
bf210566 283 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
284 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
d7599219 285const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
bf210566 286 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
287 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
9b0c60ab 288const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
289 {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
d7599219 290/////////////////////////////////////////////////////////////////////////////////
291// Cooling Tube Support (lengths are in mm and angles in degrees)
292/////////////////////////////////////////////////////////////////////////////////
bf210566 293const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
d7599219 294const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
295 = fgkSSDCoolingBlockHoleRadius[0];
bf210566 296const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
297const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
298const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
d7599219 299const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
bf210566 300 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
301const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
302 11.70*fgkmm;
d7599219 303/////////////////////////////////////////////////////////////////////////////////
304// Cooling Tube (lengths are in mm and angles in degrees)
305/////////////////////////////////////////////////////////////////////////////////
bf210566 306const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
307const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm;
308const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
d7599219 309 fgkCarbonFiberJunctionWidth;
310const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
bf210566 311 fgkSSDModuleSensorSupportDistance
312 + fgkSSDCoolingBlockLength;
9b0c60ab 313const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
d7599219 314/////////////////////////////////////////////////////////////////////////////////
315// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
316/////////////////////////////////////////////////////////////////////////////////
317const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
bf210566 318 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
d7599219 319const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
bf210566 320 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
d7599219 321const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
bf210566 322 20.0*fgkmm;
d7599219 323const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
bf210566 324 40.0;
d7599219 325const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
326 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
327const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
bf210566 328 2.5*fgkmm;
d7599219 329const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
bf210566 330 { 56.0*fgkmm, 12.0*fgkmm};
d7599219 331const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
bf210566 332 { 5.0*fgkmm, 2.9*fgkmm};
d7599219 333const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
bf210566 334 1.0*fgkmm;
d7599219 335const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
bf210566 336 6.0*fgkmm;
d7599219 337const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth =
bf210566 338 4.0*fgkmm;
d7599219 339const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
bf210566 340 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
d7599219 341/////////////////////////////////////////////////////////////////////////////////
9b0c60ab 342// SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
343/////////////////////////////////////////////////////////////////////////////////
344const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
345const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
346const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
347const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
348const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
349/////////////////////////////////////////////////////////////////////////////////
350// SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
351/////////////////////////////////////////////////////////////////////////////////
352const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
353const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
354const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
355 - fgkSSDMountingBlockHeight[1]
356 + 0.5*fgkCoolingTubeSupportHeight
357 + fgkSSDModuleCoolingBlockToSensor
e21cdd03 358 + fgkSSDModuleVerticalDisalignment
9b0c60ab 359 - fgkMountingBlockSupportDownHeight,
360 fgkSSDLay6RadiusMin
361 - fgkSSDMountingBlockHeight[1]
362 + 0.5*fgkCoolingTubeSupportHeight
363 + fgkSSDModuleCoolingBlockToSensor
e21cdd03 364 + fgkSSDModuleVerticalDisalignment
9b0c60ab 365 - fgkMountingBlockSupportDownHeight};
366const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
367 - fgkSSDMountingBlockHeight[1]
368 + 0.5*fgkCoolingTubeSupportHeight
369 + fgkSSDModuleCoolingBlockToSensor
e21cdd03 370 + fgkSSDModuleVerticalDisalignment
9b0c60ab 371 - fgkMountingBlockSupportRadius[0],
372 fgkSSDLay6RadiusMax
373 - fgkSSDMountingBlockHeight[1]
374 + 0.5*fgkCoolingTubeSupportHeight
375 + fgkSSDModuleCoolingBlockToSensor
e21cdd03 376 + fgkSSDModuleVerticalDisalignment
9b0c60ab 377 - fgkMountingBlockSupportRadius[1]};
378const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
379const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
380const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
381/////////////////////////////////////////////////////////////////////////////////
382// SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
383/////////////////////////////////////////////////////////////////////////////////
384const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
385const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
386const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
387const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
388 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
389const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
390 {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
391const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
392 {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
393const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
394const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
395const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
396const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
397const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
398const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
399/////////////////////////////////////////////////////////////////////////////////
400// SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
401/////////////////////////////////////////////////////////////////////////////////
402const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
403const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
404const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
405/////////////////////////////////////////////////////////////////////////////////
406// SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
407/////////////////////////////////////////////////////////////////////////////////
408const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
409 {10.5*fgkmm,9.25*fgkmm};
410const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
411const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
412const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
413 {182.3,177.9,84.4,70.0,35.0};
414const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
415 {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
416const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
417/////////////////////////////////////////////////////////////////////////////////
418// SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
419/////////////////////////////////////////////////////////////////////////////////
420const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
421 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
422const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
423 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
424 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
425const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
426/////////////////////////////////////////////////////////////////////////////////
427// SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
428/////////////////////////////////////////////////////////////////////////////////
429const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
430 {62.0*fgkmm,21.87*fgkmm};
431const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
432 {47.1*fgkmm,0.35*fgkmm};
433const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
434 1.0*fgkmm;
435const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
436const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
437 {43.5*fgkmm, 0.70*fgkmm};
438const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
439 0.15*fgkmm;
440const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
441 19.0*fgkmm;
442const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
443 {4.80*fgkmm,1.1*fgkmm};
444const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
445 {3.3*fgkmm,1.10*fgkmm};
446const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
447 2.1*fgkmm;
448const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
449 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
450const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
451 {1.9*fgkmm,0.15*fgkmm};
452const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
453 19*fgkmm;
454const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
455 1.0*fgkmm;
456const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
457 3.6*fgkmm;
458const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
459 61.0*fgkmm;
460const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
461 5.97*fgkmm;
462const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
463const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
464 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
465 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
466const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
467 {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
468const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
469 1.0*fgkmm;
470const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
471 = 0.15*fgkmm;
472const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
473 20.0*fgkmm;
474const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
475const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
476const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
477const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
478const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
479/////////////////////////////////////////////////////////////////////////////////
480// SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
481/////////////////////////////////////////////////////////////////////////////////
482const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
483const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
484const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {365.0*fgkmm,430.0*fgkmm};
485const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
486const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
487const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
488const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
489const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
490const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
491/////////////////////////////////////////////////////////////////////////////////
44285dfa 492ClassImp(AliITSv11GeometrySSD)
493/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 494AliITSv11GeometrySSD::AliITSv11GeometrySSD():
495 AliITSv11Geometry(),
44285dfa 496 fSSDChipMedium(),
497 fSSDChipGlueMedium(),
498 fSSDStiffenerMedium(),
499 fSSDStiffenerConnectorMedium(),
500 fSSDStiffener0603CapacitorMedium(),
501 fSSDStiffener1812CapacitorMedium(),
502 fSSDStiffenerHybridWireMedium(),
503 fSSDKaptonFlexMedium(),
504 fSSDAlTraceFlexMedium(),
505 fSSDAlTraceLadderCableMedium(),
506 fSSDKaptonLadderCableMedium(),
507 fSSDKaptonChipCableMedium(),
508 fSSDAlTraceChipCableMedium(),
509 fSSDAlCoolBlockMedium(),
510 fSSDSensorMedium(),
511 fSSDSensorSupportMedium(),
512 fSSDCarbonFiberMedium(),
513 fSSDTubeHolderMedium(),
514 fSSDCoolingTubeWater(),
515 fSSDCoolingTubePhynox(),
9b0c60ab 516 fSSDSupportRingAl(),
44285dfa 517 fSSDMountingBlockMedium(),
bf210566 518 fSSDAir(),
519 fCreateMaterials(kFALSE),
520 fTransformationMatrices(kFALSE),
521 fBasicObjects(kFALSE),
522 fcarbonfiberjunction(),
523 fcoolingtubesupport(),
524 fhybridmatrix(),
525 fssdcoolingblocksystem(),
526 fcoolingblocksystematrix(),
527 fssdstiffenerflex(),
528 fssdendflex(),
9b0c60ab 529 fendladdercoolingtubesupportmatrix(),
bf210566 530 fendladdermountingblock(),
9b0c60ab 531 fendladdermountingblockclip(),
bf210566 532 fSSDSensor5(),
533 fSSDSensor6(),
534 fSSDLayer5(),
535 fSSDLayer6(),
536 fMotherVol(),
9b0c60ab 537 fLay5LadderSupportRing(),
538 fLay6LadderSupportRing(),
e5bf64ae 539 fgkEndCapSupportSystem(),
44285dfa 540 fColorCarbonFiber(4),
541 fColorRyton(5),
bf210566 542 fColorPhynox(14),
44285dfa 543 fColorSilicon(3),
bf210566 544 fColorAl(38),
44285dfa 545 fColorKapton(6),
546 fColorPolyhamide(5),
547 fColorStiffener(9),
bf210566 548 fColorEpoxy(30),
549 fColorWater(7),
550 fColorG10(41)
44285dfa 551{
552 ////////////////////////
553 // Standard constructor
554 ////////////////////////
44285dfa 555}
556/////////////////////////////////////////////////////////////////////////////////
557AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
9acf2ecc 558 AliITSv11Geometry(s.GetDebug()),
44285dfa 559 fSSDChipMedium(s.fSSDChipMedium),
560 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
561 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
562 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
563 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
564 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
565 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
566 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
567 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
568 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
569 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
570 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
571 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
572 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
573 fSSDSensorMedium(s.fSSDSensorMedium),
574 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
575 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
576 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
577 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
578 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
9b0c60ab 579 fSSDSupportRingAl(s.fSSDSupportRingAl),
44285dfa 580 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
bf210566 581 fSSDAir(s.fSSDAir),
582 fCreateMaterials(s.fCreateMaterials),
583 fTransformationMatrices(s.fTransformationMatrices),
584 fBasicObjects(s.fBasicObjects),
585 fcarbonfiberjunction(s.fcarbonfiberjunction),
586 fcoolingtubesupport(s.fcoolingtubesupport),
587 fhybridmatrix(s.fhybridmatrix),
588 fssdcoolingblocksystem(s.fssdcoolingblocksystem),
589 fcoolingblocksystematrix(s.fcoolingblocksystematrix),
590 fssdstiffenerflex(s.fssdstiffenerflex),
591 fssdendflex(s.fssdendflex),
9b0c60ab 592 fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
bf210566 593 fendladdermountingblock(s.fendladdermountingblock),
9b0c60ab 594 fendladdermountingblockclip(s.fendladdermountingblockclip),
bf210566 595 fSSDSensor5(s.fSSDSensor5),
596 fSSDSensor6(s.fSSDSensor6),
597 fSSDLayer5(s.fSSDLayer5),
598 fSSDLayer6(s.fSSDLayer6),
44285dfa 599 fMotherVol(s.fMotherVol),
9b0c60ab 600 fLay5LadderSupportRing(s.fLay5LadderSupportRing),
601 fLay6LadderSupportRing(s.fLay6LadderSupportRing),
e5bf64ae 602 fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
44285dfa 603 fColorCarbonFiber(s.fColorCarbonFiber),
604 fColorRyton(s.fColorRyton),
605 fColorPhynox(s.fColorPhynox),
606 fColorSilicon(s.fColorSilicon),
607 fColorAl(s.fColorAl),
608 fColorKapton(s.fColorKapton),
609 fColorPolyhamide(s.fColorPolyhamide),
610 fColorStiffener(s.fColorStiffener),
bf210566 611 fColorEpoxy(s.fColorEpoxy),
612 fColorWater(s.fColorWater),
613 fColorG10(s.fColorG10)
44285dfa 614{
615 ////////////////////////
616 // Copy Constructor
617 ////////////////////////
d7599219 618}
619/////////////////////////////////////////////////////////////////////////////////
44285dfa 620AliITSv11GeometrySSD& AliITSv11GeometrySSD::
621operator=(const AliITSv11GeometrySSD &s){
622 ////////////////////////
623 // Assignment operator
624 ////////////////////////
625 this->~AliITSv11GeometrySSD();
626 new(this) AliITSv11GeometrySSD(s);
627 return *this;
628/*
629 if(&s == this) return *this;
630 fMotherVol = s.fMotherVol;
631 return *this;
632 */
633}
bf210566 634///////////////////////////////////////////////////////////////////////////////
635void AliITSv11GeometrySSD::CreateTransformationMatrices(){
636 ///////////////////////////////////////////////////////////////////////
637 // Method generating the trasformation matrix for the whole SSD Geometry
638 ///////////////////////////////////////////////////////////////////////
639 // Setting some variables for Carbon Fiber Supportmatrix creation
640 //////////////////////////////////////////////////////////////////////
641 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
642 * CosD(fgkCarbonFiberJunctionAngle[0]);
643 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
644 + fgkCarbonFiberSupportTopEdgeDist[0]
645 + fgkCarbonFiberSupportWidth);
646 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
647 * TanD(fgkCarbonFiberJunctionAngle[0]);
648 TGeoRotation* carbonfiberot[3];
649 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
650 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
651 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
652 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
653 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
654 * CosD(fgkCarbonFiberTriangleAngle),0.,
655 - fgkCarbonFiberTriangleLength
656 * SinD(fgkCarbonFiberTriangleAngle)};
657 ///////////////////////////////////////////
658 //Setting Local Translations and Rotations:
659 ///////////////////////////////////////////
660 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
661 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
662 0.5*carbonfibersupportheight,NULL);
663 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
664 2.*symmetryplaneposition+transvector[1],
665 transvector[2], carbonfiberot[2]);
666 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
667 /////////////////////////////////////////////////////////////
668 // Carbon Fiber Support Transformations
669 /////////////////////////////////////////////////////////////
670 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
671 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
672 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
673 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
674 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
675 }
676 /////////////////////////////////////////////////////////////
677 // Carbon Fiber Junction Transformation
678 /////////////////////////////////////////////////////////////
679 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
680 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
681 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
682 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
683 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
684 localcarbonfiberjunctionmatrix[i] =
685 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
686 localcarbonfiberjunctionrot[i] =
687 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
688 localcarbonfiberjunctiontrans[i] =
689 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 690 }
bf210566 691 ///////////////////////
692 // Setting Translations
693 ///////////////////////
694 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
695 localcarbonfiberjunctiontrans[1][0] =
696 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
697 localcarbonfiberjunctiontrans[2][0] =
698 new TGeoTranslation(fgkCarbonFiberTriangleLength
699 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
700 fgkCarbonFiberTriangleLength
701 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
702 localcarbonfiberjunctiontrans[0][1] =
703 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
704 localcarbonfiberjunctiontrans[1][1] =
705 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
706 localcarbonfiberjunctiontrans[2][1] =
707 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
708 ////////////////////
709 // Setting Rotations
710 ////////////////////
711 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
712 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
713 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
714 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
715 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
716 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
717 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
718 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
719 ////////////////////////////////////////
720 // Setting Carbon Fiber Junction matrix
721 ////////////////////////////////////////
722 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
723 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
724 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
725 localcarbonfiberjunctionmatrix[i][j] =
726 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
727 *localcarbonfiberjunctionrot[i][j]);
728 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
729 }
d7599219 730 }
bf210566 731 /////////////////////////////////////////////////////////////
732 // Carbon Fiber Lower Support Transformations
733 /////////////////////////////////////////////////////////////
734 TGeoTranslation* localcarbonfiberlowersupportrans[2];
735 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
736 fgkCarbonFiberLowerSupportVolumePosition[1]
737 + fgkCarbonFiberLowerSupportVolumePosition[0],
738 0.0);
739 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
740 fgkCarbonFiberJunctionWidth
741 - fgkCarbonFiberLowerSupportWidth
742 - fgkCarbonFiberLowerSupportVolumePosition[0]
743 - fgkCarbonFiberLowerSupportVolumePosition[1],
744 - 0.5*fgkCarbonFiberLowerSupportHeight);
745 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
746 fcarbonfiberlowersupportrans[0] =
747 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
748 fcarbonfiberlowersupportrans[1] =
749 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
750 /////////////////////////////////////////////////////////////
751 // SSD Sensor Support Transformations
752 /////////////////////////////////////////////////////////////
753 const Int_t kssdsensorsupportmatrixnumber = 3;
754 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
755 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
756 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
757 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
758 localssdsensorsupportmatrix[i] =
759 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
760 localssdsensorsupportrot[i] =
761 new TGeoRotation*[kssdsensorsupportmatrixnumber];
762 localssdsensorsupportrans[i] =
763 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 764 }
bf210566 765 ///////////////////////
766 // Setting Translations
767 ///////////////////////
768 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
769 0.5*fgkSSDSensorSideSupportWidth,
770 0.0);
771 localssdsensorsupportrans[1][0] =
772 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
773 localssdsensorsupportrans[2][0] =
774 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
775 localssdsensorsupportrans[0][1] =
776 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
777 0.5*fgkSSDSensorSideSupportThickness[0],
778 0.0);
779 localssdsensorsupportrans[1][1] =
780 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
781 - 0.5*fgkSSDSensorSideSupportThickness[0]
782 - fgkSSDModuleSensorSupportDistance,
783 0.0);
784 localssdsensorsupportrans[2][1] =
785 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
786 - fgkSSDSensorCenterSupportPosition,
787 0.5*fgkSSDSensorCenterSupportWidth
788 - 0.5*fgkSSDModuleSensorSupportDistance,
789 fgkSSDSensorCenterSupportThickness[0]);
790 localssdsensorsupportrans[0][2] =
791 new TGeoTranslation(fgkCarbonFiberTriangleLength
792 + fgkCarbonFiberJunctionToSensorSupport,
793 fgkCarbonFiberJunctionWidth
794 - 0.5*(fgkCarbonFiberLowerSupportWidth
795 + fgkSSDSensorCenterSupportLength
796 - fgkSSDSensorCenterSupportThickness[0])
797 - fgkSSDSensorCenterSupportPosition,
798 0.0);
799 localssdsensorsupportrans[1][2] =
800 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
801 localssdsensorsupportrans[2][2] =
802 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
803 ////////////////////
804 // Setting Rotations
805 ////////////////////
806 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
807 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
808 localssdsensorsupportrot[i][j] = new TGeoRotation();
809 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
810 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
811 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 812 }
bf210566 813 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
814 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
815 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
816 ////////////////////////////////////////
817 // SSD Sensor Support matrix
818 ////////////////////////////////////////
819 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
820 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
821 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
822 localssdsensorsupportmatrix[i][j] =
823 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
824 *localssdsensorsupportrot[i][j]);
825 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
826 }
d7599219 827 }
44285dfa 828 /////////////////////////////////////////////////////////////
bf210566 829 // SSD Cooling Tube Support Transformations
44285dfa 830 /////////////////////////////////////////////////////////////
bf210566 831 const Int_t kcoolingtubesupportmatrixnumber = 2;
832 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
833 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
834 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 835 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 836 /fgkCoolingTubeSupportRmax);
bf210566 837 localcoolingtubesupportrans[0] =
838 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 839 + 2.*(fgkCoolingTubeSupportLength
44285dfa 840 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 841 + fgkCarbonFiberTriangleLength
bf210566 842 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
843 localcoolingtubesupportrans[1] =
844 new TGeoTranslation(fgkCarbonFiberJunctionLength
845 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
846 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
847 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
848 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
849 - 0.5*(fgkCarbonFiberLowerSupportWidth
850 + fgkSSDSensorCenterSupportLength
851 - fgkSSDSensorCenterSupportThickness[0])
852 + 0.5*fgkSSDSensorLength,
853 - 0.5*fgkCoolingTubeSupportHeight);
854 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
855 localcoolingtubesupportrot[i] = new TGeoRotation();
856 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
857 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
858 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
859 localcoolingtubesupportmatrix[i] =
860 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
861 *localcoolingtubesupportrot[i]);
862 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
863 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
864 (*localcoolingtubesupportmatrix[0]));
865 /////////////////////////////////////////////////////////////
9b0c60ab 866 // End Ladder SSD Cooling Tube Support Transformations
867 /////////////////////////////////////////////////////////////
868 TGeoTranslation** localendladdercooltubetrans[2];
869 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
870 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
871 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
872 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
873 - (fgkCoolingTubeSupportLength
874 - fgkCoolingTubeSupportRmax),
875 fgkEndLadderMountingBlockPosition[0]
876 - fgkendladdercoolingsupportdistance[0]
877 + 0.5*fgkCoolingTubeSupportWidth,
878 - 0.5*fgkCoolingTubeSupportHeight);
879 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
880 - (fgkCoolingTubeSupportLength
881 - fgkCoolingTubeSupportRmax),
882 fgkEndLadderMountingBlockPosition[0]
883 + fgkendladdercoolingsupportdistance[1]
884 + 0.5*fgkCoolingTubeSupportWidth,
885 - 0.5*fgkCoolingTubeSupportHeight);
886 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
887 - fgkCoolingTubeSupportRmax)
888 + fgkCarbonFiberTriangleLength
889 - 2.0*fgkCarbonFiberJunctionLength,
890 0.0,
891 0.0);
892 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
893 fgkendladdercoolingsupportdistance[0]
894 + fgkendladdercoolingsupportdistance[1],
895 0.0);
896 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
897 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
898 + fgkCarbonFiberJunctionLength
899 - fgkCoolingTubeSupportLength,
900 fgkEndLadderCarbonFiberLowerJunctionLength[1]
901 - 0.5*fgkCoolingTubeSupportWidth
902 -fgkendladdercoolingsupportdistance[2],
903 - 0.5*fgkCoolingTubeSupportHeight);
904 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
905 + fgkCoolingTubeSupportLength
906 - fgkCoolingTubeSupportRmax
907 - fgkCarbonFiberJunctionLength,
908 fgkEndLadderCarbonFiberLowerJunctionLength[1]
909 - 0.5*fgkCoolingTubeSupportWidth
910 - fgkendladdercoolingsupportdistance[2],
911 - 0.5*fgkCoolingTubeSupportHeight);
912 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
913 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
914 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
915 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
916 (*localcoolingtubesupportrot[1]));
917 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
918 (*localcoolingtubesupportrot[1]));
919 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
920 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
921 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
922 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
923 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
924
925 fendladdercoolingtubesupportmatrix[1][0] =
926 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
927 *(*localcoolingtubesupportrot[1]));
928 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
929 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
930 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
931 /////////////////////////////////////////////////////////////
bf210566 932 // SSD Cooling Tube Transformations
933 /////////////////////////////////////////////////////////////
934 TGeoRotation* localcoolingtuberot = new TGeoRotation();
935 localcoolingtuberot->SetAngles(0.,90.,0.);
936 TGeoTranslation** localcoolingtubetrans[4];
937 TVector3** localcoolingtubevect[4];
938 for(Int_t i=0; i<4; i++){
939 localcoolingtubevect[i] = new TVector3*[2];
940 localcoolingtubetrans[i] = new TGeoTranslation*[2];
941 fcoolingtubematrix[i] = new TGeoHMatrix*[2];
d7599219 942 }
bf210566 943 localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
944 -fgkCarbonFiberTriangleLength),
945 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
946 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
947 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
948 - 0.5*(fgkCarbonFiberLowerSupportWidth
949 + fgkSSDSensorCenterSupportLength
950 - fgkSSDSensorCenterSupportThickness[0])+
951 0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
952 - 2.0*fgkSSDModuleStiffenerPosition[1]
953 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
954 - 0.5*fgkCoolingTubeSupportWidth,
955 - 0.5*fgkCoolingTubeSupportHeight);
956 localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
957 localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
958 - 2.0*fgkSSDModuleStiffenerPosition[1]
959 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
960 + fgkCoolingTubeSupportWidth,
961 localcoolingtubevect[0][0]->Z());
962 localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
963 + fgkCarbonFiberTriangleLength,
964 localcoolingtubevect[0][0]->Y(),
965 localcoolingtubevect[0][0]->Z());
966 localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
967 + fgkCarbonFiberTriangleLength,
968 localcoolingtubevect[0][1]->Y(),
969 localcoolingtubevect[0][1]->Z());
970 localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
971 - fgkCarbonFiberTriangleLength),
972 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
973 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
974 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
975 - 0.5*(fgkCarbonFiberLowerSupportWidth
976 + fgkSSDSensorCenterSupportLength
977 - fgkSSDSensorCenterSupportThickness[0])
978 + fgkSSDModuleStiffenerPosition[1]
979 - 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
980 - 0.5*fgkCoolingTubeSupportHeight);
981 localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
982 + fgkCarbonFiberTriangleLength,
983 localcoolingtubevect[2][0]->Y(),
984 localcoolingtubevect[2][0]->Z());
985 localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
986 - fgkCarbonFiberTriangleLength),
987 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
988 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
989 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
990 - 0.5*(fgkCarbonFiberLowerSupportWidth
991 + fgkSSDSensorCenterSupportLength
992 - fgkSSDSensorCenterSupportThickness[0])
993 + fgkSSDSensorLength
994 - 0.5*fgkSSDModuleStiffenerPosition[1],
995 - 0.5*fgkCoolingTubeSupportHeight);
996 localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
997 + fgkCarbonFiberTriangleLength,
998 localcoolingtubevect[3][0]->Y(),
999 - 0.5*fgkCoolingTubeSupportHeight);
1000 for(Int_t i=0; i<4; i++)
1001 for(Int_t j=0; j<2; j++){
1002 localcoolingtubetrans[i][j] =
1003 new TGeoTranslation(localcoolingtubevect[i][j]->X(),
1004 localcoolingtubevect[i][j]->Y(),
1005 localcoolingtubevect[i][j]->Z());
1006 fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
1007 * (*localcoolingtuberot));
1008 }
1009 /////////////////////////////////////////////////////////////
9b0c60ab 1010 // SSD End Ladder Cooling Tube Transformations
1011 /////////////////////////////////////////////////////////////
1012 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1013 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1014 TGeoTranslation** localendlladdercoolingtubetrans[2];
1015 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
1016 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
1017 for(Int_t i=0; i<2; i++)
1018 for(Int_t j=0; j<(i==0?6:4); j++)
1019 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1020 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1021 - fgkCoolingTubeSupportRmax)
1022 + fgkCarbonFiberJunctionLength,
1023 0.5*(fgkEndLadderMountingBlockPosition[0]
1024 - fgkendladdercoolingsupportdistance[0]),
1025 - 0.5*fgkCoolingTubeSupportHeight);
1026 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1027 - fgkCoolingTubeSupportRmax)
1028 - fgkCarbonFiberJunctionLength
1029 + fgkCarbonFiberTriangleLength,
1030 0.5*(fgkEndLadderMountingBlockPosition[0]
1031 - fgkendladdercoolingsupportdistance[0]),
1032 - 0.5*fgkCoolingTubeSupportHeight);
1033 localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1034 - fgkCoolingTubeSupportRmax)
1035 + fgkCarbonFiberJunctionLength,
1036 fgkEndLadderMountingBlockPosition[0]
1037 - fgkendladdercoolingsupportdistance[0]
1038 + 0.5*(fgkendladdercoolingsupportdistance[0]
1039 + fgkendladdercoolingsupportdistance[1]
1040 + fgkCoolingTubeSupportWidth),
1041 - 0.5*fgkCoolingTubeSupportHeight);
1042 localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
1043 - fgkCoolingTubeSupportRmax)
1044 - fgkCarbonFiberJunctionLength
1045 + fgkCarbonFiberTriangleLength,
1046 fgkEndLadderMountingBlockPosition[0]
1047 - fgkendladdercoolingsupportdistance[0]
1048 + 0.5*(fgkendladdercoolingsupportdistance[0]
1049 + fgkendladdercoolingsupportdistance[1]
1050 + fgkCoolingTubeSupportWidth),
1051 - 0.5*fgkCoolingTubeSupportHeight);
1052 localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
1053 - fgkCoolingTubeSupportRmax)
1054 + fgkCarbonFiberJunctionLength,
1055 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1056 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1057 - fgkEndLadderMountingBlockPosition[0]
1058 - fgkendladdercoolingsupportdistance[1]
1059 - fgkCoolingTubeSupportWidth),
1060 - 0.5*fgkCoolingTubeSupportHeight);
1061 localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
1062 - fgkCoolingTubeSupportRmax)
1063 - fgkCarbonFiberJunctionLength
1064 + fgkCarbonFiberTriangleLength,
1065 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1066 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1067 - fgkEndLadderMountingBlockPosition[0]
1068 - fgkendladdercoolingsupportdistance[1]
1069 - fgkCoolingTubeSupportWidth),
1070 - 0.5*fgkCoolingTubeSupportHeight);
1071 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1072 - fgkCoolingTubeSupportRmax)
1073 + fgkCarbonFiberJunctionLength,
1074 - 0.50 * (fgkMountingBlockToSensorSupport
1075 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1076 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1077 + fgkSSDSensorOverlap
1078 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1079 - fgkendladdercoolingsupportdistance[2]
1080 - fgkEndLadderMountingBlockPosition[1]
1081 - fgkCoolingTubeSupportWidth)
1082 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1083 - fgkendladdercoolingsupportdistance[2]
1084 - fgkCoolingTubeSupportWidth,
1085 - 0.5*fgkCoolingTubeSupportHeight);
1086 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1087 - fgkCoolingTubeSupportRmax)
1088 - fgkCarbonFiberJunctionLength
1089 + fgkCarbonFiberTriangleLength,
1090 - 0.50 * (fgkMountingBlockToSensorSupport
1091 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1092 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1093 + fgkSSDSensorOverlap
1094 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1095 - fgkendladdercoolingsupportdistance[2]
1096 - fgkEndLadderMountingBlockPosition[1]
1097 - fgkCoolingTubeSupportWidth)
1098 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1099 - fgkendladdercoolingsupportdistance[2]
1100 - fgkCoolingTubeSupportWidth,
1101 - 0.5*fgkCoolingTubeSupportHeight);
1102 localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1103 - fgkCoolingTubeSupportRmax)
1104 + fgkCarbonFiberJunctionLength,
1105 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1106 - 0.5*fgkendladdercoolingsupportdistance[2],
1107 - 0.5*fgkCoolingTubeSupportHeight);
1108 localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
1109 - fgkCoolingTubeSupportRmax)
1110 - fgkCarbonFiberJunctionLength
1111 + fgkCarbonFiberTriangleLength,
1112 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1113 - 0.5*fgkendladdercoolingsupportdistance[2],
1114 - 0.5*fgkCoolingTubeSupportHeight);
1115 fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
1116 fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
1117 for(Int_t i=0; i<2; i++)
1118 for(Int_t j=0; j<(i==0?6:4); j++){
1119 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1120 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1121 }
1122 /////////////////////////////////////////////////////////////
bf210566 1123 // SSD Hybrid Components Transformations
1124 /////////////////////////////////////////////////////////////
1125 const Int_t khybridmatrixnumber = 3;
1126 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1127 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1128 0.5*fgkSSDStiffenerWidth,
1129 0.5*fgkSSDStiffenerHeight);
1130 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1131 fgkSSDModuleStiffenerPosition[1],0.0);
1132
1133 localhybridtrans[2] = new TGeoTranslation(
1134 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1135 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1136 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1137 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1138 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1139 - fgkSSDSensorCenterSupportThickness[0]),
1140 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1141 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight));
1142 fhybridmatrix = new TGeoHMatrix();
1143 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1144 /////////////////////////////////////////////////////////////
1145 // SSD Cooling Block Transformations
1146 /////////////////////////////////////////////////////////////
1147 const Int_t kcoolingblockmatrixnumber = 4;
1148 TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
1149 localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
1150 - fgkCoolingTubeSupportRmin),0.0,
1151 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1152 localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
1153 - 0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
1154 0.0,fgkSSDStiffenerHeight);
1155 localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
1156 localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
1157 fcoolingblocksystematrix = new TGeoHMatrix();
1158 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
1159 fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
1160 /////////////////////////////////////////////////////////////
1161 // SSD Stiffener Flex Transformations
1162 /////////////////////////////////////////////////////////////
1163 const Int_t klocalflexmatrixnumber = 4;
1164 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1165 for(Int_t i=0; i<fgkflexnumber; i++)
1166 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1167 for(Int_t i=0; i<fgkflexnumber; i++)
1168 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1169 localflexmatrix[i][j] = new TGeoCombiTrans();
1170 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1171 - 2.*fgkSSDModuleStiffenerPosition[1]
1172 - fgkSSDStiffenerWidth;
1173 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1174 +0.5*fgkSSDStiffenerLength,
1175 0.5*fgkSSDStiffenerWidth,
1176 -0.5*fgkSSDStiffenerHeight
1177 -0.5*fgkSSDFlexHeight[0]);
1178 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1179 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1180 -0.5*fgkSSDStiffenerWidth,
1181 -0.5*fgkSSDStiffenerHeight
1182 -0.5*fgkSSDFlexHeight[0]);
1183 TGeoRotation* localflexrot = new TGeoRotation();
1184 localflexrot->SetAngles(180.,0.,0.);
1185 localflexmatrix[1][0]->SetRotation(localflexrot);
1186 for(Int_t i=0; i<fgkflexnumber; i++)
1187 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1188 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1189 for(Int_t i=0; i<fgkflexnumber; i++){
1190 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1191 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1192 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1193 }
bf210566 1194 /////////////////////////////////////////////////////////////
1195 // SSD End Flex Transformations
1196 /////////////////////////////////////////////////////////////
1197 TGeoRotation* localendflexrot = new TGeoRotation();
1198 localendflexrot->SetAngles(0.0,90.0,0.0);
1199 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1200 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1201 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1202 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1203 * TMath::DegToRad()*ssdflexradiusmax
1204 - fgkSSDFlexLength[2]-TMath::Pi()
1205 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
1206 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1207 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1208 + fgkSSDFlexLength[2];
1209 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1210 0.5*fgkSSDFlexWidth[0],
1211 2.*fgkSSDStiffenerHeight
1212 + 0.5*fgkSSDFlexHeight[0]);
1213 localendflexmatrix->SetRotation(localendflexrot);
1214 for(Int_t i=0; i<fgkflexnumber; i++)
1215 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1216 /////////////////////////////////////////////////////////////
1217 // End Ladder Carbon Fiber Junction
1218 /////////////////////////////////////////////////////////////
1219 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1220 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1221 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1222 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1223 localendladdercarbonfiberjunctionmatrix[i]
1224 = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1225 localendladdercarbonfiberjunctionrot[i]
1226 = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1227 localendladdercarbonfiberjunctiontrans[i]
1228 = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1229 fendladdercarbonfiberjunctionmatrix[i]
1230 = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
d7599219 1231 }
bf210566 1232 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1233 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1234 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1235 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1236 }
1237 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1238 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1239 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1240 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1241 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1242 0.0,0.0);
1243 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1244 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1245 * SinD(fgkCarbonFiberTriangleAngle),
1246 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1247 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1248 }
1249 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1250 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1251 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1252 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1253 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1254 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1255 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1256 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1257 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1258 localendladdercarbonfiberjunctionglobalmatrix[i] =
1259 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1260 *localendladdercarbonfiberjunctionglobalrot[i]);
1261 }
1262 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1263 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1264 localendladdercarbonfiberjunctionmatrix[i][j] =
1265 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1266 *localendladdercarbonfiberjunctionrot[i][j]);
1267 fendladdercarbonfiberjunctionmatrix[i][j] =
1268 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1269 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1270 }
1271 /////////////////////////////////////////////////////////////
1272 // End Ladder Carbon Fiber Support
1273 /////////////////////////////////////////////////////////////
1274 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1275 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1276 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1277 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1278 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1279 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1280 }
1281 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1282 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1283 fendladdercarbonfibermatrix[i][j] =
1284 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1285 *(*fcarbonfibersupportmatrix[j]));
1286 /////////////////////////////////////////////////////////////
1287 // End Ladder SSD Mounting Block
1288 /////////////////////////////////////////////////////////////
1289 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1290 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1291 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1292 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1293 + fgkSSDMountingBlockLength[1])
1294 + 0.5*fgkCarbonFiberTriangleLength,
1295 fgkEndLadderMountingBlockPosition[i],
1296 - fgkSSDMountingBlockHeight[1]
1297 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1298 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1299 endladdermountingblockrot->SetAngles(0.,90.,0.);
1300 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1301 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1302 /////////////////////////////////////////////////////////////
1303 // End Ladder SSD Mounting Block Clip Matrix
1304 /////////////////////////////////////////////////////////////
1305 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1306 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1307
1308 TGeoRotation* localendladdercliprot = new TGeoRotation();
1309 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1310 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1311 - fgkSSDMountingBlockLength[1])
1312 + fgkSSDMountingBlockLength[0],0.,0.);
1313 localendladdercliprot->SetAngles(90.,180.,-90.);
1314 TGeoCombiTrans* localendladderclipcombitrans =
1315 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1316 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1317 for(Int_t j=0; j<2; j++){
1318 fendladdermountingblockclipmatrix[i][j] =
1319 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1320 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1321 }
bf210566 1322 /////////////////////////////////////////////////////////////
1323 // End Ladder Carbon Fiber Lower Support
1324 /////////////////////////////////////////////////////////////
1325 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1326 fendladderlowersupptrans[i] =
1327 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1328 + 0.5*fgkSSDMountingBlockWidth),
1329 - 0.5*fgkCarbonFiberLowerSupportHeight);
1330 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1331 fgkCarbonFiberLowerSupportVolumePosition[1]
1332 + fgkCarbonFiberLowerSupportVolumePosition[0],
1333 0.0);
1334 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1335 /////////////////////////////////////////////////////////////
1336 // Matrix for positioning Ladder into mother volume
1337 /////////////////////////////////////////////////////////////
1338 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1339 for(Int_t i=0; i<fgkladdernumber; i++)
1340 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1341 TGeoRotation* localladdermotherrot = new TGeoRotation();
1342 localladdermotherrot->SetAngles(0.,90.,0.);
1343 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1344 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1345 for(Int_t i=0; i<fgkladdernumber; i++){
1346 localladdermothertrans[i] = new TGeoTranslation(0.,
1347 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1348 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1349 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1350 * fgkCarbonFiberJunctionWidth,0.);
1351 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1352 *localladdermotherrot);
1353 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1354 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1355 }
44285dfa 1356 /////////////////////////////////////////////////////////////
bf210566 1357 // Ladder Cables Matrices
44285dfa 1358 /////////////////////////////////////////////////////////////
44285dfa 1359 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1360 + fgkSSDFlexHeight[1];
44285dfa 1361 Double_t ssdladdercabletransx[3];
1362 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1363 * SinD(2.*fgkSSDFlexAngle)
1364 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1365 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1366 - ssdladdercabletransx[0]
bf210566 1367 / SinD(2.*fgkSSDFlexAngle))
1368 * CosD(fgkSSDFlexAngle);
44285dfa 1369 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1370 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1371 - fgkSSDFlexLength[2]-TMath::Pi()
1372 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1373 - fgkSSDLadderCableWidth)
bf210566 1374 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1375 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1376 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1377 ssdladdercabletransx[1]
bf210566 1378 * TanD(fgkSSDFlexAngle),
44285dfa 1379 ssdladdercabletransx[2]
bf210566 1380 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1381 TGeoRotation* localladdercablerot[3];
bf210566 1382 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1383 localladdercablerot[0]->SetAngles(90.,0.,0.);
1384 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1385 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1386 * (*localladdercablerot[0]));
1387 ////////////////////////////////////////////
1388 // LocalLadderCableCombiTransMatrix
1389 ////////////////////////////////////////////
1390 const Int_t klocalladdersidecablesnumber = 2;
1391 const Int_t klocalladdercombitransnumber = 5;
1392 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1393 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1394 localladdercablecombitransmatrix[i] =
1395 new TGeoCombiTrans*[klocalladdercombitransnumber];
1396 ///////////////////////////////////////////
1397 // Left Side Ladder Cables Transformations
1398 ///////////////////////////////////////////
1399 localladdercablecombitransmatrix[0][0] =
d7599219 1400 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1401 0.,0.,NULL);
bf210566 1402 localladdercablecombitransmatrix[0][1] =
1403 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1404 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1405 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1406 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1407 - 0.5*(fgkCarbonFiberLowerSupportWidth
1408 + fgkSSDSensorCenterSupportLength
1409 - fgkSSDSensorCenterSupportThickness[0]),
1410 - (fgkSSDModuleCoolingBlockToSensor
1411 + 0.5*fgkCoolingTubeSupportHeight
1412 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1413 - fgkSSDChipHeight),NULL);
44285dfa 1414 localladdercablecombitransmatrix[0][2] =
d7599219 1415 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1416 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1417 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1418 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1419 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1420 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1421 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1422 new TGeoRotation("",180.,0.,0.));
44285dfa 1423 localladdercablecombitransmatrix[0][4] =
1424 new TGeoCombiTrans(-ssdladdercabletransx[0]
1425 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1426 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1427 0.,
1428 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1429 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1430 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1431 + ssdladdercabletransz[2],localladdercablerot[2]);
1432 ///////////////////////////////////////////
1433 // Rigth Side Ladder Cables Transformations
1434 ///////////////////////////////////////////
bf210566 1435 TGeoCombiTrans* localladdercablessdmodulematrix =
1436 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1437 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1438 fgkSSDStiffenerWidth,
1439 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1440 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1441 localladdercablecombitransmatrix[1][i] =
bf210566 1442 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1443 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1444 ///////////////////////////////////////////
bf210566 1445 // Setting LadderCableHMatrix
44285dfa 1446 ///////////////////////////////////////////
bf210566 1447 Int_t beamaxistrans[2][3];
1448 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1449 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1450 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1451 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1452 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1453 beamaxistrans[1][2] = beamaxistrans[1][0];
1454 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1455 TGeoRotation* laddercablerot = new TGeoRotation();
1456 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1457 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1458 Double_t* laddercabletransvector;
1459 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1460 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1461 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1462 }
1463 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1464 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1465 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1466 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1467 localladdercablehmatrix[i][j]->MultiplyLeft(
1468 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1469 }
1470 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1471 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1472 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1473 laddercabletransvector[1]
bf210566 1474 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1475 * fgkCarbonFiberJunctionWidth,
bf210566 1476 laddercabletransvector[2]);
1477 laddercablecombitrans->SetRotation(*laddercablerot);
1478 laddercablecombitrans->SetTranslation(*laddercabletrans);
1479 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1480 }
1481 fladdercablematrix[i][2] =
1482 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1483 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1484 fladdercablematrix[i][3] =
1485 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1486 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1487 }
1488 for(Int_t i=0; i<fgkladdercablesnumber; i++)
1489 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1490 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1491 ///////////////////////////////////////////
1492 // Setting Ladder HMatrix
1493 ///////////////////////////////////////////
1494 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1495 fgkSSDLay6SensorsNumber};
1496 for(Int_t i=0; i<fgkladdernumber; i++){
1497 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1498 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1499 fladdermatrix[i][j] = new TGeoHMatrix();
1500 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1501 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1502 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1503 }
1504 }
1505 ///////////////////////////////////////////
1506 // Setting SSD Sensor Matrix
1507 ///////////////////////////////////////////
1508 TGeoCombiTrans* localssdsensorcombitrans[2];
1509 TGeoRotation* localssdsensorrot = new TGeoRotation();
1510 localssdsensorrot->SetAngles(0.,90.,0.);
1511 TGeoTranslation* localssdsensortrans[2];
1512 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1513 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1514 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1515 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1516 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1517 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1518 - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1519 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
02d4acf9 1520 - fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment
e21cdd03 1521 + (fgkSSDSensorSideSupportHeight[1]
bf210566 1522 - fgkSSDSensorSideSupportHeight[0]));
1523 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1524 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1525 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1526 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1527 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1528 - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1529 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
02d4acf9 1530 -fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment);
bf210566 1531 for(Int_t i=0; i<2; i++)
1532 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1533 *localssdsensorrot);
1534 for(Int_t i=0; i<fgkladdernumber; i++){
1535 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1536 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1537 switch(i){
1538 case 0: //Ladder of Layer5
1539 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1540 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1541 *localssdsensorcombitrans[1])));
1542 break;
1543 case 1: //Ladder of Layer6
1544 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1545 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1546 *localssdsensorcombitrans[0])));
1547 break;
1548 }
1549 }
1550 }
1551 //////////////////////////
1552 // Setting SSD End Ladder
1553 //////////////////////////
1554 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1555 for(Int_t i=0; i<2; i++){
1556 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1557 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1558 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1559 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1560 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1561 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1562 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1563 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1564 }
1565 /////////////////////////////////////////////////////
1566 // Setting the CombiTransformation to pass ITS center
1567 /////////////////////////////////////////////////////
1568 Double_t itscentertransz[fgklayernumber];
1569 itscentertransz[0] = fgkSSDLay5LadderLength
1570 - fgkLay5CenterITSPosition;
1571 itscentertransz[1] = fgkSSDLay6LadderLength
1572 - fgkLay6CenterITSPosition;
1573 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1574 + 0.5*fgkCoolingTubeSupportHeight;
1575 TGeoRotation* itscenterrot[3];
1576 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1577 itscenterrot[0]->SetAngles(90.,180.,-90.);
1578 itscenterrot[1]->SetAngles(0.,90.,0.);
1579 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1580 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1581 for(Int_t i=0; i<fgklayernumber; i++)
1582 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1583 itssensortransy,
1584 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1585 - itscentertransz[i],itscenterrot[2]);
1586 TGeoRotation** locallayerrot[fgklayernumber];
1587 TGeoTranslation** locallayertrans[fgklayernumber];
1588 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1589 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1590 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1591 - fgkLay5CenterITSPosition);
1592 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1593 - fgkLay6CenterITSPosition);
1594 const Int_t kssdlayladdernumber[fgklayernumber] =
1595 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1596 for(Int_t i=0; i<fgklayernumber; i++){
1597 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1598 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1599 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1600 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1601 }
1602 Double_t layerladderangleposition[fgklayernumber] =
1603 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1604 Double_t layerradius = 0.;
1605 for(Int_t i=0; i<fgklayernumber; i++){
1606 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1607 switch(i){
1608 case 0: //Ladder of Layer5
1609 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1610 break;
1611 case 1: //Ladder of Layer6
1612 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1613 break;
1614 }
1615 locallayerrot[i][j] = new TGeoRotation();
1616 locallayertrans[i][j] = new TGeoTranslation();
1617 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1618 locallayertrans[i][j]->SetTranslation(layerradius
1619 * CosD(90.0+j*layerladderangleposition[i]),
1620 layerradius
1621 * SinD(90.0+j*layerladderangleposition[i]),0.);
1622 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1623 *locallayerrot[i][j]);
1624 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1625 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1626 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1627 }
1628 }
44285dfa 1629 /////////////////////////////////////////////////////////////
bf210566 1630 // Deallocating memory
44285dfa 1631 /////////////////////////////////////////////////////////////
bf210566 1632 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1633 delete carbonfiberot[i];
1634 delete localcarbonfibersupportmatrix[i];
1635 }
1636 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1637 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1638 delete localcarbonfiberjunctionmatrix[i][j];
1639 delete localcarbonfiberjunctionrot[i][j];
1640 delete localcarbonfiberjunctiontrans[i][j];
1641 }
1642 delete [] localcarbonfiberjunctionmatrix[i];
1643 delete [] localcarbonfiberjunctionrot[i];
1644 delete [] localcarbonfiberjunctiontrans[i];
1645 }
1646 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1647 delete localcarbonfiberlowersupportrans[i];
1648 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1649 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1650 delete localssdsensorsupportmatrix[i][j];
1651 delete localssdsensorsupportrot[i][j];
1652 delete localssdsensorsupportrans[i][j];
1653 }
1654 delete [] localssdsensorsupportmatrix[i];
1655 delete [] localssdsensorsupportrot[i];
1656 delete [] localssdsensorsupportrans[i];
1657 }
1658 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1659 delete localcoolingtubesupportmatrix[i];
1660 delete localcoolingtubesupportrot[i];
1661 delete localcoolingtubesupportrans[i];
1662 }
1663 for(Int_t i=0; i<4; i++){
1664 for(Int_t j=0; j<2; j++){
1665 delete localcoolingtubevect[i][j];
1666 delete localcoolingtubetrans[i][j];
1667 }
1668 delete [] localcoolingtubevect[i];
1669 delete [] localcoolingtubetrans[i];
1670 }
9b0c60ab 1671 delete endladdermountingblockrot;
bf210566 1672 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1673 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
1674 for(Int_t i=0; i<fgkflexnumber; i++){
1675 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1676 delete localflexmatrix[i][j];
1677 delete [] localflexmatrix[i];
1678 }
9b0c60ab 1679 delete localendlladdercoolingtuberot;
1680 for(Int_t i=0; i<2; i++){
1681 for(Int_t j=0; j<(i==0?6:4); j++)
1682 delete localendlladdercoolingtubetrans[i][j];
1683 delete [] localendlladdercoolingtubetrans[i];
1684 }
1685
bf210566 1686 delete localflexrot;
1687 delete localendflexrot;
1688 delete localendflexmatrix;
1689 for(Int_t i=0; i<fgkladdernumber; i++){
1690 delete localladdermothertrans[i];
1691 delete localladdermothercombitrans[i];
1692 }
1693 delete localladdermotherrot;
1694 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1695 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1696 delete localendladdercarbonfiberjunctionmatrix[i][j];
1697 delete localendladdercarbonfiberjunctionrot[i][j];
1698 delete localendladdercarbonfiberjunctiontrans[i][j];
1699 }
1700 delete [] localendladdercarbonfiberjunctionmatrix[i];
1701 delete [] localendladdercarbonfiberjunctionrot[i];
1702 delete [] localendladdercarbonfiberjunctiontrans[i];
1703 delete localendladdercarbonfiberjunctionglobalrot[i];
1704 delete localendladdercarbonfiberjunctionglobaltrans[i];
1705 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1706 }
9b0c60ab 1707 for(Int_t i=0; i<2; i++){
1708 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1709 delete [] localendladdercooltubetrans[i];
1710 }
1711 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1712 delete localendladdercarbonfibertrans[i];
1713 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1714 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1715 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1716 delete localladdercablecombitransmatrix[i][j];
1717 delete []localladdercablecombitransmatrix[i];
1718 }
9b0c60ab 1719 delete localendladdercliprot;
1720 delete localendladdercliptrans;
bf210566 1721 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1722 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1723 delete localladdercablehmatrix[i][j];
1724 delete []localladdercablehmatrix[i];
1725 }
1726 delete laddercablerot;
1727 delete laddercabletrans;
1728 delete laddercablecombitrans;
1729 delete localladdercablessdmodulematrix;
1730 delete localssdsensorrot;
1731 for(Int_t i=0; i<2; i++){
1732 delete localssdsensortrans[i];
1733 delete localssdsensorcombitrans[i];
1734 }
1735 for(Int_t i=0; i<fgklayernumber; i++){
1736 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1737 delete locallayerrot[i][j];
1738 delete locallayertrans[i][j];
1739 delete locallayercombitrans[i][j];
1740 }
1741 delete [] locallayerrot[i];
1742 delete [] locallayertrans[i];
1743 delete [] locallayercombitrans[i];
1744 delete localbeamaxistrans[i];
1745 }
1746 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1747 for(Int_t i=0; i<fgkladdernumber; i++){
1748 for(Int_t j=0; j<fgkladdernumber; j++)
1749 delete ladderglobalmatrix[i][j];
1750 delete [] ladderglobalmatrix[i];
1751 }
1752 /////////////////////////////////////////////////////////////
1753 fTransformationMatrices = kTRUE;
d7599219 1754}
bf210566 1755///////////////////////////////////////////////////////////////////////////////
1756void AliITSv11GeometrySSD::CreateBasicObjects(){
1757 /////////////////////////////////////////////////////////////
1758 // Method generating the Objects of SSD Geometry
1759 /////////////////////////////////////////////////////////////
1760 // SSD Sensor
1761 ///////////////////////////////////
1762 SetSSDSensor();
1763 /////////////////////////////////////////////////////////////
1764 // Carbon Fiber Support
1765 /////////////////////////////////////////////////////////////
1766 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1767 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1768 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1769 /////////////////////////////////////////////////////////////
bf210566 1770 // Carbon Fiber Junction
44285dfa 1771 /////////////////////////////////////////////////////////////
bf210566 1772 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
1773 /////////////////////////////////////////////////////////////
1774 // Carbon Fiber Lower Support
1775 /////////////////////////////////////////////////////////////
1776 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1777 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1778 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1779 /////////////////////////////
1780 // SSD Sensor Support
1781 /////////////////////////////
1782 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1783 new TGeoVolume*[fgkssdsensorsupportnumber];
44285dfa 1784 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
bf210566 1785 fgkSSDSensorSideSupportThickness[1]};
1786 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1787 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1788 fgkSSDSensorSideSupportHeight[i],
1789 fgkSSDSensorSideSupportWidth,
1790 sidesupporthickness);
1791 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1792 fgkSSDSensorCenterSupportHeight[i],
1793 fgkSSDSensorCenterSupportWidth,
1794 sidesupporthickness);
1795 }
1796 /////////////////////////////////////////////////////////////
1797 // SSD Cooling Tube Support
1798 /////////////////////////////////////////////////////////////
1799 Int_t edgesnumber = 16;
1800 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1801 /////////////////////////////////////////////////////////////
1802 // SSD Hybrid
1803 /////////////////////////////////////////////////////////////
1804 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1805 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1806 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1807 /////////////////////////////////////////////////////////////
1808 // SSD Cooling Block System
1809 /////////////////////////////////////////////////////////////
1810 fssdcoolingblocksystem = GetCoolingBlockSystem();
1811 /////////////////////////////////////////////////////////////
1812 // SSD Cooling Tube
1813 /////////////////////////////////////////////////////////////
1814 TList* coolingtubelist = GetCoolingTubeList();
1815 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
1816 fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
9b0c60ab 1817 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
1818 fendladdercoolingtube[i] =
1819 (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
bf210566 1820 /////////////////////////////////////////////////////////////
1821 // SSD Flex
1822 /////////////////////////////////////////////////////////////
1823 fssdstiffenerflex = GetSSDStiffenerFlex();
1824 fssdendflex = GetSSDEndFlex();
1825 ///////////////////////////////////
1826 // End Ladder Carbon Fiber Junction
1827 ///////////////////////////////////
1828 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1829 fendladdercarbonfiberjunction[i] =
1830 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1831 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1832 fendladdercarbonfiberjunction[i][0] =
1833 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
1834 fendladdercarbonfiberjunction[i][1] =
1835 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
1836 }
1837 ///////////////////////////////////
1838 // End Ladder Mounting Block
1839 ///////////////////////////////////
1840 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1841 ///////////////////////////////////
1842 // End Ladder Mounting Block
1843 ///////////////////////////////////
1844 fendladdermountingblockclip = GetMountingBlockClip();
1845 ///////////////////////////////////
1846 // Ladder Support
1847 ///////////////////////////////////
1848 TList* laddersupportlist = GetMountingBlockSupport(20);
1849 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1850 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1851 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1852 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
bf210566 1853 /////////////////////////////////////////////////////////////
1854 // Deallocating memory
44285dfa 1855 /////////////////////////////////////////////////////////////
bf210566 1856 delete carbonfibersupportlist;
1857 delete carbonfiberlowersupportlist;
1858 delete ssdhybridcomponentslist;
9b0c60ab 1859 delete laddersupportlist;
44285dfa 1860 /////////////////////////////////////////////////////////////
bf210566 1861 fBasicObjects = kTRUE;
1862}
1863/////////////////////////////////////////////////////////////////////////////////
1864void AliITSv11GeometrySSD::SetSSDSensor(){
1865 ////////////////////////////////////////////////////////////////
1866 // Method generating SSD Sensors: it sets the private variables
1867 // fSSDSensor5, fSSDSensor6
1868 ////////////////////////////////////////////////////////////////
44285dfa 1869 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1870 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1871 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
44285dfa 1872 0.5*ssdsensitivewidth,
bf210566 1873 0.5*fgkSSDSensorHeight,
1874 0.5*ssdsensitivelength);
1875 TGeoVolume* ssdsensorsensitiveLay5 =
02d4acf9 1876 new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1877 TGeoVolume* ssdsensorsensitiveLay6 =
02d4acf9 1878 new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1879 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1880 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
44285dfa 1881 TGeoBBox* ssdsensorinsensitiveshape[2];
1882 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1883 0.5*fgkSSDSensorInsensitiveWidth,
bf210566 1884 0.5*fgkSSDSensorHeight,
1885 0.5*fgkSSDSensorLength);
44285dfa 1886 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
44285dfa 1887 0.5*ssdsensitivewidth,
bf210566 1888 0.5*fgkSSDSensorHeight,
1889 0.5*fgkSSDSensorInsensitiveWidth);
44285dfa 1890 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1891 "SSDSensorInsensitive2"};
44285dfa 1892 TGeoVolume* ssdsensorinsensitive[2];
1893 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1894 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1895 fSSDSensorMedium);
1896 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1897 }
bf210566 1898 /////////////////////////////////////////////////////////////
1899 // Virtual Volume containing SSD Sensor
1900 /////////////////////////////////////////////////////////////
1901 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1902 0.5*fgkSSDSensorWidth,
1903 0.5*fgkSSDSensorHeight,
1904 0.5*fgkSSDSensorLength);
1905 fSSDSensor5 = new TGeoVolume("ITSsddSensor5",virtualSSDSensorShape,
1906 fSSDAir);
1907 fSSDSensor6 = new TGeoVolume("ITSsddSensor6",virtualSSDSensorShape,
1908 fSSDAir);
1909 /////////////////////////////////////////////////////////////
1910 for(Int_t i=0; i<4; i++){
1911 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1912 ssdsensorinsensitive[1],i<2?1:2,
1913 new TGeoTranslation(
1914 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1915 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1916 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1917 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1918 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
44285dfa 1919 ssdsensorinsensitive[1],i<2?1:2,
bf210566 1920 new TGeoTranslation(
1921 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1922 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1923 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1924 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1925 }
1926 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1927 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1928}
bf210566 1929///////////////////////////////////////////////////////////////////////////////
1930TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1931 /////////////////////////////////////////////////////////////
1932 // Method generating the Carbon Fiber Support
1933 /////////////////////////////////////////////////////////////
1934 const Int_t kvertexnumber = 4;
1935 const Int_t kshapesnumber = 2;
1936 TVector3** vertexposition[kshapesnumber];
1937 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1938 Double_t carbonfibersupportxaxisEdgeproj =
1939 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1940 * TMath::DegToRad());
1941 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1942 / fgkCarbonFiberSupportXAxisLength);
1943 /////////////////////
1944 //Vertex Positioning
1945 ////////////////////
1946 vertexposition[0][0] = new TVector3();
1947 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1948 fgkCarbonFiberSupportYAxisLength);
1949 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1950 carbonfibersupportxaxisEdgeproj
1951 * TMath::Tan(theta));
1952 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1953 - carbonfibersupportxaxisEdgeproj,
1954 fgkCarbonFiberSupportYAxisLength
1955 - vertexposition[0][2]->Y());
1956 ////////////////////////////////////////////////////
1957 //Setting the parameters for Isometry Transformation
1958 ////////////////////////////////////////////////////
1959 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1960 + fgkCarbonFiberSupportTopEdgeDist[0]
1961 + fgkCarbonFiberSupportWidth);
1962 Double_t* param = new Double_t[4];
1963 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1964 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
1965 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1966 (GetReflection(vertexposition[0][j],param))->Y());
1967 char* carbonfibersupportshapename[kshapesnumber] =
1968 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
1969 char* carbonfibersupportname[kshapesnumber] =
1970 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1971 TGeoArb8* carbonfibersupportshape[kshapesnumber];
1972 TGeoVolume* carbonfibersupport[kshapesnumber];
1973 TList* carbonfibersupportlist = new TList();
1974 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1975 Double_t carbonfibersupportheight =
1976 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1977 *TMath::DegToRad());
1978 for(Int_t i = 0; i< kshapesnumber; i++){
1979 carbonfibersupportshape[i] =
1980 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1981 carbonfibersupportshapename[i],i==0 ? 1: -1);
1982 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1983 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1984 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1985 carbonfibersupportlist->Add(carbonfibersupport[i]);
1986 }
1987 /////////////////////////////////////////////////////////////
1988 // Deallocating memory
1989 /////////////////////////////////////////////////////////////
1990 for(Int_t i=0; i< kshapesnumber; i++){
1991 for(Int_t j=0; j< kvertexnumber; j++)
1992 delete vertexposition[i][j];
1993 delete [] vertexposition[i];
1994 }
1995 delete [] param;
44285dfa 1996 /////////////////////////////////////////////////////////////
bf210566 1997 return carbonfibersupportlist;
d7599219 1998}
1999/////////////////////////////////////////////////////////////////////////////////
bf210566 2000TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 2001 /////////////////////////////////////////////////////////////
bf210566 2002 // Method generating SSD Carbon Fiber Junction
44285dfa 2003 /////////////////////////////////////////////////////////////
bf210566 2004 const Int_t kvertexnumber = 6;
2005 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
2006 Double_t reflectionparam[3] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
2007 * TMath::DegToRad()),-1.,0.};
2008 TVector3* vertex[kvertexnumber];
2009 vertex[0] = new TVector3();
2010 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2011 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2012 * TMath::DegToRad()),
2013 fgkCarbonFiberJunctionEdge[0]
2014 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
2015 * TMath::DegToRad()));
2016 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
2017 fgkCarbonFiberJunctionEdge[1]);
2018 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
2019 vertex[1] = GetReflection(vertex[5],reflectionparam);
2020 vertex[2] = GetReflection(vertex[4],reflectionparam);
2021 Double_t xvertexpoints[6], yvertexpoints[6];
2022 for(Int_t i=0; i<kvertexnumber; i++)
2023 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
2024 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2025 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
2026 carbonfiberjunctionshape->DefineSection(1,0.5*width);
2027 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
2028 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
2029 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
2030 /////////////////////////////////////////////////////////////
2031 // Deallocating memory
2032 /////////////////////////////////////////////////////////////
2033 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
2034 /////////////////////////////////////////////////////////////
2035 return carbonfiberjunction;
2036}
2037////////////////////////////////////////////////////////////////////////////////
2038TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
2039 /////////////////////////////////////////////////////////////
2040 // Method generating the Carbon Fiber Lower Support
2041 /////////////////////////////////////////////////////////////
2042 const Int_t kvertexnumber = 4;
2043 const Int_t kshapesnumber = 2;
2044 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
2045 fgkCarbonFiberLowerSupportWidth};
2046 TVector3** vertexposition[kshapesnumber];
2047 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2048 new TVector3*[kvertexnumber];
2049 //First Shape Vertex Positioning
2050 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2051 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2052 - fgkCarbonFiberLowerSupportLowerLenght);
2053 vertexposition[0][2] = new TVector3();
2054 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2055 //Second Shape Vertex Positioning
2056 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2057 - fgkCarbonFiberLowerSupportVolumePosition[0])
2058 / fgkCarbonFiberTriangleLength);
2059 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2060 vertexposition[0][0]->X()*TMath::Tan(theta)
2061 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2062 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2063 vertexposition[0][1]->X()*TMath::Tan(theta)
2064 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2065 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2066 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2067 fgkCarbonFiberLowerSupportVolumePosition[1]);
2068 char* carbonfiberlowersupportshapename[kshapesnumber] =
2069 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
2070 char* carbonfiberlowersupportname[kshapesnumber] =
2071 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2072 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2073 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2074 TList* carbonfiberlowersupportlist = new TList();
2075 for(Int_t i = 0; i< kshapesnumber; i++){
2076 carbonfiberlowersupportshape[i] =
2077 GetArbShape(vertexposition[i],width,
2078 fgkCarbonFiberLowerSupportHeight,
2079 carbonfiberlowersupportshapename[i]);
2080 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2081 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2082 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2083 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2084 }
2085 /////////////////////////////////////////////////////////////
2086 // Deallocating memory
2087 /////////////////////////////////////////////////////////////
2088 for(Int_t i=0; i< kshapesnumber; i++){
2089 for(Int_t j=0; j< kvertexnumber; j++)
2090 delete vertexposition[i][j];
2091 delete [] vertexposition[i];
2092 }
2093 /////////////////////////////////////////////////////////////
2094 return carbonfiberlowersupportlist;
2095}
2096///////////////////////////////////////////////////////////////////////////////
2097TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2098 Double_t width, Double_t* thickness)const{
2099 /////////////////////////////////////////////////////////////
2100 // Method generating the Sensor Support
2101 /////////////////////////////////////////////////////////////
2102 const Int_t kvertexnumber = 6;
2103 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2104 TVector3* vertexposition[kvertexnumber];
2105 vertexposition[0] = new TVector3();
2106 vertexposition[1] = new TVector3(0.0,length);
2107 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2108 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2109 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2110 vertexposition[5] = new TVector3(vertexposition[4]->X());
2111 Double_t xvertexpoints[6], yvertexpoints[6];
2112 for(Int_t i=0; i<kvertexnumber; i++)
2113 xvertexpoints[i] = vertexposition[i]->X(),
2114 yvertexpoints[i] = vertexposition[i]->Y();
2115 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2116 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2117 ssdsensorsupportshape->DefineSection(1,0.5*width);
2118 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2119 ssdsensorsupportshape,fSSDSensorSupportMedium);
2120 /////////////////////////////////////////////////////////////
2121 // Deallocating memory
2122 /////////////////////////////////////////////////////////////
2123 for (Int_t i=0; i<kvertexnumber; i++)
2124 delete vertexposition[i];
2125 /////////////////////////////////////////////////////////////
2126 return ssdsensorsupport;
2127}
2128////////////////////////////////////////////////////////////////////////////////
2129TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2130 /////////////////////////////////////////////////////////////
2131 // Method generating the Cooling Tube Support
2132 /////////////////////////////////////////////////////////////
2133 if(nedges%2!=0) nedges--;
2134 const Int_t kvertexnumber = nedges+5;
2135 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2136 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2137 Double_t angle = 90.+phi;
2138 Double_t psi = 90.-phi;
2139 ///////////////////////////////////////
2140 // Vertex Positioning for TGeoXTru
2141 ///////////////////////////////////////
2142 TVector3** vertexposition = new TVector3*[kvertexnumber];
2143 vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
2144 fgkCoolingTubeSupportRmin*SinD(angle));
2145 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2146 fgkCoolingTubeSupportRmax*SinD(angle));
2147 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2148 fgkCoolingTubeSupportRmax);
2149 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2150 fgkCoolingTubeSupportRmax);
2151 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2152 vertexposition[1]->Y());
2153 for(Int_t i=0; i<nedges; i++)
2154 vertexposition[i+5] =
2155 new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
2156 fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
2157 ///////////////////////////////////////////////////////////////////////
2158 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2159 ///////////////////////////////////////////////////////////////////////
2160 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2161 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2162 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2163 for(Int_t i=0; i<kvertexnumber; i++){
2164 xvertexpoints[i] = vertexposition[i]->X();
2165 yvertexpoints[i] = vertexposition[i]->Y();
2166 }
2167 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2168 yvertexpoints);
2169 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2170 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2171 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2172 coolingtubesupportarcshape,
2173 fSSDTubeHolderMedium);
2174 coolingtubesupportarc->SetLineColor(fColorG10);
2175 //////////////////////////////////////////////////////////////////////////
2176 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2177 //////////////////////////////////////////////////////////////////////////
2178 TGeoTubeSeg* coolingtubesupportsegshape =
2179 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2180 fgkCoolingTubeSupportRmax,
2181 0.5*fgkCoolingTubeSupportWidth,
2182 phi,360-phi);
2183 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2184 coolingtubesupportsegshape,
2185 fSSDTubeHolderMedium);
2186 coolingtubesupportseg->SetLineColor(fColorG10);
2187 //////////////////////////////////////////////////////////////////////////
2188 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2189 //////////////////////////////////////////////////////////////////////////
2190 Double_t* boxorigin = new Double_t[3];
2191 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2192 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2193 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2194 0.5*fgkCoolingTubeSupportHeight,
2195 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2196 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2197 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2198 coolingtubesupportbox->SetLineColor(fColorG10);
2199 //////////////////////////////////////////////////////////////////////////
2200 // Cooling Tube for Cooling Tube Support
2201 //////////////////////////////////////////////////////////////////////////
2202 TGeoXtru* coolingtubearcshape[2];
2203 coolingtubearcshape[0] = new TGeoXtru(2);
2204 Double_t* xvert = new Double_t[nedges+2];
2205 Double_t* yvert = new Double_t[nedges+2];
2206 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2207 ////////////////////////////////////////
2208 // Positioning the vertices for TGeoXTru
2209 ////////////////////////////////////////
2210 xvert[0] = 0., yvert[0] = 0.;
2211 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2212 for(Int_t i=0; i< nedges; i++)
2213 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2214 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2215 ////////////////////////////////////////
2216 // Defining TGeoXTru PolyGone
2217 ////////////////////////////////////////
2218 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2219 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2220 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2221 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2222 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2223 TGeoVolume* coolingtubearc[2];
2224 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2225 coolingtubearcshape[0],fSSDCoolingTubeWater);
2226 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2227 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2228 coolingtubearc[0]->SetLineColor(fColorWater);
2229 coolingtubearc[1]->SetLineColor(fColorPhynox);
2230 ////////////////////////////////////////////
2231 // Defining TGeoTubeSeg Part of Cooling Tube
2232 ////////////////////////////////////////////
2233 TGeoTubeSeg* coolingtubesegshape[2];
2234 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2235 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2236 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2237 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2238 TGeoVolume* coolingtubeseg[2];
2239 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2240 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2241 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2242 coolingtubesegshape[1],fSSDCoolingTubeWater);
2243 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2244 coolingtubeseg[1]->SetLineColor(fColorWater);
2245 /////////////////////////////////////////////////////////////
2246 // Virtual Volume containing Cooling Tube Support
2247 /////////////////////////////////////////////////////////////
2248 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2249 const Int_t kvirtualvertexnumber = 8;
2250 TVector3* virtualvertex[kvirtualvertexnumber];
2251 ////////////////////////////////////////
2252 // Positioning the vertices for TGeoXTru
2253 ////////////////////////////////////////
2254 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2255 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2256 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2257 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2258 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2259 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2260 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2261 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2262 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2263 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2264 xmothervertex[i] = virtualvertex[i]->X(),
2265 ymothervertex[i] = virtualvertex[i]->Y();
2266 ////////////////////////////////////////
2267 // Defining TGeoXTru PolyGone
2268 ////////////////////////////////////////
2269 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2270 ymothervertex);
2271 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2272 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2273 TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2274 virtualCoolingTubeSupportShape,fSSDAir);
2275 ////////////////////////////////////////
2276 // Positioning Volumes in Virtual Volume
2277 ////////////////////////////////////////
2278 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2279 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2280 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2281 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2282 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2283 virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2284 virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2285 virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2286 virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2287 /////////////////////////////////////////////////////////////
2288 // Deallocating memory
2289 /////////////////////////////////////////////////////////////
2290 delete [] vertexposition;
2291 delete xvertexpoints;
2292 delete yvertexpoints;
2293 delete xvert;
2294 delete yvert;
2295 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2296 delete virtualvertex[i];
2297 /////////////////////////////////////////////////////////////
2298 return virtualcoolingtubesupport;
2299}
2300/////////////////////////////////////////////////////////////////////////////////
2301TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2302 /////////////////////////////////////////////////////////////
2303 // Method generating List containing SSD Hybrid Components
2304 /////////////////////////////////////////////////////////////
2305 TList* ssdhybridlist = new TList();
2306 const Int_t kssdstiffenernumber = 2;
2307 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2308 - 2.*fgkSSDModuleStiffenerPosition[1]
2309 - fgkSSDStiffenerWidth;
2310 Double_t ssdchipcablesradius[kssdstiffenernumber];
2311 for(Int_t i=0; i<kssdstiffenernumber; i++)
2312 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2313 - fgkSSDChipCablesHeight[0]
2314 - fgkSSDChipCablesHeight[1]);
2315 /////////////////////////////////////////////////////////////
2316 // Mother Volumes Containers
2317 /////////////////////////////////////////////////////////////
2318 const Int_t kmothernumber = 2;
2319 const Int_t kmothervertexnumber = 12;
2320 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2321 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2322 ///////////////////////
2323 // Setting the vertices
2324 ///////////////////////
2325 xmothervertex[0][0] = -0.5*fgkSSDStiffenerLength;
2326 xmothervertex[0][1] = xmothervertex[0][0];
2327 xmothervertex[0][2] = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
2328 xmothervertex[0][3] = xmothervertex[0][2];
2329 xmothervertex[0][4] = xmothervertex[0][0];
2330 xmothervertex[0][5] = xmothervertex[0][4];
2331 xmothervertex[0][6] = -xmothervertex[0][0];
2332 xmothervertex[0][7] = xmothervertex[0][6];
2333 xmothervertex[0][8] = -xmothervertex[0][2];
2334 xmothervertex[0][9] = xmothervertex[0][8];
2335 xmothervertex[0][10] = xmothervertex[0][7];
2336 xmothervertex[0][11] = xmothervertex[0][10];
2337 for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
2338 for(Int_t i = 0; i<kmothernumber; i++){
2339 ymothervertex[i][0] = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
2340 + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
2341 ymothervertex[i][1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
2342 ymothervertex[i][2] = ymothervertex[i][1];
2343 ymothervertex[i][3] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
2344 ymothervertex[i][4] = ymothervertex[i][3];
2345 ymothervertex[i][5] = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
2346 ymothervertex[i][6] = ymothervertex[i][5];
2347 ymothervertex[i][7] = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
2348 ymothervertex[i][8] = ymothervertex[i][7];
2349 ymothervertex[i][9] = 0.5*fgkSSDStiffenerWidth;
2350 ymothervertex[i][10] = ymothervertex[i][9];
2351 ymothervertex[i][11] = ymothervertex[i][0];
2352 }
2353 TGeoXtru* ssdhybridmothershape[kmothernumber];
2354 TGeoVolume* ssdhybridmother[kmothernumber];
2355 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2356 for(Int_t i=0; i<kmothernumber; i++){
2357 ssdhybridmothershape[i] = new TGeoXtru(2);
2358 ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
2359 ymothervertex[i]);
2360 ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2361 -fgkSSDChipCablesHeight[i+2]);
2362 ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
2363 ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
2364 fSSDAir);
2365 }
2366 /////////////////////////////////////////////////////////////
2367 // SSD Stiffener
2368 /////////////////////////////////////////////////////////////
2369 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2370 0.5*fgkSSDStiffenerLength,
2371 0.5*fgkSSDStiffenerWidth,
2372 0.5*fgkSSDStiffenerHeight);
2373 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2374 fSSDStiffenerMedium);
2375 ssdstiffener->SetLineColor(fColorStiffener);
2376 TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
2377 for(Int_t i=0; i<kssdstiffenernumber; i++)
2378 ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
2379 /////////////////////////////////////////////////////////////
2380 // SSD Chip System
2381 /////////////////////////////////////////////////////////////
2382 TList* ssdchipsystemlist = GetSSDChipSystem();
2383 Double_t ssdchipseparation = fgkSSDSensorLength
2384 - 2.*fgkSSDModuleStiffenerPosition[1]
2385 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
2386 - 0.5*fgkSSDChipWidth);
2387 Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
2388 + fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
2389 TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
2390 - 0.5*ssdchipsystemlength,
2391 0.5*(ssdstiffenerseparation-ssdchipseparation),
2392 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
2393////////////////////////////
2394// Capacitor 0603-2200 nF
2395///////////////////////////
2396 const Int_t knapacitor0603number = 5;
2397 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
2398 0.5*fgkSSDCapacitor0603Length,
2399 0.5*fgkSSDCapacitor0603Width,
2400 0.5*fgkSSDCapacitor0603Height);
2401 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2402 fSSDStiffener0603CapacitorMedium);
2403 capacitor0603->SetLineColor(fColorAl);
bf210566 2404 for(Int_t i=0; i<kmothernumber; i++){
2405 for(Int_t j=0; j<kssdstiffenernumber; j++){
2406 ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
2407 for(Int_t k=1; k<knapacitor0603number+1; k++){
2408 ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
2409 new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
2410 j*ssdstiffenerseparation
2411 + 0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
2412 + (j==0? -1:+1)*fgkSSDCapacitor0603Width),
2413 - 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
2414 }
2415 }
2416 ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
2417 ssdhybridlist->Add(ssdhybridmother[i]);
2418 }
2419/////////////////////////////////////////////////////////////
2420// Mother Volume Containing Capacitor Part
2421/////////////////////////////////////////////////////////////
2422 const Int_t kcapacitormothernumber = 8;
2423 Double_t xcapacitorvertex[kcapacitormothernumber];
2424 Double_t ycapacitorvertex[kcapacitormothernumber];
2425 ///////////////////////
2426 // Setting the vertices
2427 ///////////////////////
2428 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2429 xcapacitorvertex[1] = xcapacitorvertex[0];
2430 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2431 xcapacitorvertex[3] = xcapacitorvertex[2];
2432 xcapacitorvertex[4] = xcapacitorvertex[0];
2433 xcapacitorvertex[5] = xcapacitorvertex[0];
2434 xcapacitorvertex[6] = -xcapacitorvertex[0];
2435 xcapacitorvertex[7] = xcapacitorvertex[6];
2436 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2437 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2438 ycapacitorvertex[2] = ycapacitorvertex[1];
2439 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2440 ycapacitorvertex[4] = ycapacitorvertex[3];
2441 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2442 ycapacitorvertex[6] = ycapacitorvertex[5];
2443 ycapacitorvertex[7] = ycapacitorvertex[0];
2444 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2445 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2446 ycapacitorvertex);
2447 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2448 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2449 TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2450 fSSDAir);
d7599219 2451////////////////////////////
bf210566 2452// Connector
d7599219 2453///////////////////////////
bf210566 2454 const Int_t kssdconnectornumber = 2;
2455 TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2456 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2457 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2458 + fgkSSDConnectorAlHeight};
2459 const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2460 TGeoVolume* ssdconnector[kssdconnectornumber];
2461 for(Int_t i=0; i<kssdconnectornumber; i++){
2462 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2463 0.5*fgkSSDConnectorWidth,
2464 0.5*((1-i)*fgkSSDConnectorAlHeight
2465 + i*fgkSSDConnectorNiHeight),
2466 i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2467 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2468 i==0 ? fSSDAlTraceFlexMedium
2469 : fSSDStiffenerConnectorMedium);
2470 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2471 }
2472 TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2473 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2474 + fgkSSDConnectorPosition[0]
2475 - fgkSSDConnectorSeparation
2476 - 1.5*fgkSSDConnectorLength,
2477 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2478 - fgkSSDConnectorPosition[1]
2479 - ssdconnectorshape[0]->GetDY(),0.0);
2480 ssdconnectortrans[1] = new TGeoTranslation(
2481 - ssdstiffenershape->GetDX()
2482 + fgkSSDConnectorPosition[0]
2483 - 0.5*fgkSSDConnectorLength,
2484 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2485 - fgkSSDConnectorPosition[1]
2486 - ssdconnectorshape[0]->GetDY(),0.0);
2487 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2488 - fgkSSDConnectorPosition[0]
2489 + fgkSSDConnectorSeparation
2490 + 1.5*fgkSSDConnectorLength,
2491 -(ssdstiffenershape->GetDY()
2492 - fgkSSDConnectorPosition[1]
2493 - ssdconnectorshape[0]->GetDY()),0.0);
2494 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2495 - fgkSSDConnectorPosition[0]
2496 + 0.5*fgkSSDConnectorLength,
2497 -(ssdstiffenershape->GetDY()
2498 - fgkSSDConnectorPosition[1]
2499 - ssdconnectorshape[0]->GetDY()),0.0);
2500 for(Int_t i=0; i<2*kssdconnectornumber; i++)
2501 for(Int_t j=0; j<kssdconnectornumber; j++)
2502 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2503////////////////////////////
2504// Capacitor 1812-330 nF
2505///////////////////////////
2506 Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2507 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2508 0.5*fgkSSDCapacitor1812Length,
2509 0.5*fgkSSDCapacitor1812Width,
bf210566 2510 0.5*fgkSSDCapacitor1812Height,
2511 ssdcapacitor1812origin);
44285dfa 2512 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2513 fSSDStiffener1812CapacitorMedium);
2514 capacitor1812->SetLineColor(fColorAl);
bf210566 2515 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2516 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2517 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2518 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
d7599219 2519////////////////////////////
2520//Hybrid Wire
2521////////////////////////////
44285dfa 2522 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2523 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2524 - fgkSSDConnectorSeparation;
44285dfa 2525 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2526 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
44285dfa 2527 Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
2528 + TMath::Power(wirey,2));
2529 Double_t wireangle = TMath::ATan(wirex/wirey);
2530 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2531 fgkSSDWireRadius, 0.5*ssdwireradius);
2532 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2533 fSSDStiffenerHybridWireMedium);
2534 hybridwire->SetLineColor(fColorPhynox);
2535 TGeoCombiTrans* hybridwirecombitrans[2];
2536 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2537 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2538 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2539 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2540 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2541 ssdstiffenershape->GetDZ()
2542 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
d7599219 2543 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2544 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2545 0.0,
2546 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2547 0.0,
2548 new TGeoRotation("HybridWireRot2",
2549 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2550 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2551 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2552 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2553 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2554 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2555 /////////////////////////////////////////////////////////////
bf210566 2556 // Deallocating memory
44285dfa 2557 /////////////////////////////////////////////////////////////
bf210566 2558 delete hybridwirecombitrans[0];
2559 delete hybridwirecombitrans[1];
2560 delete ssdchipsystemlist;
2561 return ssdhybridlist;
2562 /////////////////////////////////////////////////////////////
2563}
2564///////////////////////////////////////////////////////////////////////////////
2565TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2566 /////////////////////////////////////////////////////////////
2567 // SSD Cooling Block System
2568 /////////////////////////////////////////////////////////////
2569 // SSD Cooling Block and Cooling Tube Transformations
2570 /////////////////////////////////////////////////////////////
2571 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2572 localcoolingblockrot->SetAngles(0.,90.,0.);
2573 TGeoCombiTrans* localcoolingblockmatrix =
2574 new TGeoCombiTrans(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
2575 TGeoTranslation* localcoolingblocktrans;
2576 TVector3* coolingblocktransvector;
2577 coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2578 + fgkSSDCoolingBlockLength,
2579 fgkSSDSensorLength
2580 - 2.*fgkSSDModuleStiffenerPosition[1]
2581 - fgkSSDCoolingBlockWidth);
2582 const Int_t kcoolingblocktransnumber = 2;
2583 const Int_t kcoolingblocknumber = 4;
2584 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2585 TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2586 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2587 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2588 TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2589 localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
2590 0.5*fgkSSDCoolingBlockWidth,
2591 fgkSSDCoolingBlockHoleCenter);
2592 TGeoCombiTrans* localcoolingtubematrix = new TGeoCombiTrans(*localcoolingtubetrans,
2593 *localcoolingtuberot);
2594 Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2595 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
2596 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2597 localcoolingblocktrans=
2598 new TGeoTranslation(i*coolingblocktransvector->X()+2*coolingtubedistance,
2599 j*coolingblocktransvector->Y(),
2600 - 0.5*(fgkSSDCoolingBlockHoleCenter
2601 + fgkCoolingTubeRmax));
2602 coolingblockmatrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
2603 *(*localcoolingblockmatrix));
2604 coolingtubematrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans)
2605 *(*localcoolingtubematrix));
2606 }
d7599219 2607 }
bf210566 2608 /////////////////////////////////////////////////////////////
2609 // Virtual Volume containing CoolingBlock System
2610 /////////////////////////////////////////////////////////////
2611 TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2612 const Int_t kmothervertexnumber = 16;
2613 Double_t xmothervertex[kmothervertexnumber];
2614 Double_t ymothervertex[kmothervertexnumber];
2615 ///////////////////////
2616 // Setting the vertices
2617 ///////////////////////fgkCoolingTubeSupportRmax
2618 xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2619 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2620 + fgkSSDCoolingBlockWidth;
2621 xmothervertex[2] = coolingblocktransvector->X()
2622 + fgkSSDCoolingBlockLength
2623 + 4*coolingtubedistance;
2624 ymothervertex[2] = ymothervertex[1];
2625 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2626 xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2627 ymothervertex[4] = ymothervertex[0];
2628 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2629 xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2630 ymothervertex[6] = ymothervertex[5];
2631 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2632 - fgkSSDCoolingBlockWidth;
2633 xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2634 xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2635 - coolingtubedistance;
2636 xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2637 ymothervertex[10] = ymothervertex[9];
2638 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2639 xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2640 xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2641 xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2642 ymothervertex[14] = ymothervertex[13];
2643 xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2644 //////////////////////////////////////////////////////////
2645 coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2646 xmothervertex,ymothervertex);
2647 coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2648 + fgkCoolingTubeRmax));
2649 coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2650 + fgkCoolingTubeRmax));
2651 TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
2652 coolingsystemothershape,fSSDAir);
2653 /////////////////////////////////////////////////////////////
2654 // SSD Cooling Tube Part
2655 /////////////////////////////////////////////////////////////
2656 TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
2657 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2658 0.5*fgkSSDCoolingBlockWidth);
2659 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
2660 0.5*fgkSSDCoolingBlockWidth);
2661 TGeoVolume* coolingtube[fgkcoolingtubenumber];
2662 coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
2663 fSSDCoolingTubePhynox);
2664 coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
2665 fSSDCoolingTubeWater);
2666 coolingtube[0]->SetLineColor(fColorPhynox);
2667 coolingtube[1]->SetLineColor(fColorWater);
2668 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2669 /////////////////////////////////////////////////////////////
2670 // Adding Cooling block to mother volume
2671 /////////////////////////////////////////////////////////////
2672 for(Int_t i=0; i<kcoolingblocknumber; i++){
2673 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2674 coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
2675 coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
d7599219 2676 }
bf210566 2677 /////////////////////////////////////////////////////////////
2678 // Deallocating memory
2679 /////////////////////////////////////////////////////////////
2680 delete coolingblocktransvector;
2681 delete localcoolingblocktrans;
2682 delete localcoolingblockrot;
2683 delete localcoolingblockmatrix;
2684 delete localcoolingtubetrans;
2685 delete localcoolingtuberot;
2686 /////////////////////////////////////////////////////////////
2687 // Checking overlaps
2688 /////////////////////////////////////////////////////////////
6727e2db 2689 //coolingsystemother->CheckOverlaps(0.01);
bf210566 2690 /////////////////////////////////////////////////////////////
2691 return coolingsystemother;
d7599219 2692}
2693/////////////////////////////////////////////////////////////////////////////////
bf210566 2694TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2695 /////////////////////////////////////////////////////////////
bf210566 2696 // SSD Flex
44285dfa 2697 /////////////////////////////////////////////////////////////
bf210566 2698 const Int_t kssdflexlayernumber = 2;
2699 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2700 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2701 const Int_t kmothervertexnumber = 17;
2702 Double_t xmothervertex[kmothervertexnumber];
2703 Double_t ymothervertex[kmothervertexnumber];
2704 /////////////////////////////////////////////
2705 // Auxiliary variables for vertex positioning
2706 /////////////////////////////////////////////
2707 const Int_t kssdflexboxnumber = 5;
44285dfa 2708 Double_t ssdflexboxlength[kssdflexboxnumber];
2709 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2710 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2711 * fgkSSDChipSeparationLength
2712 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2713 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2714 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2715 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2716 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2717 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2718 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2719 - ssdflexboxlength[1];
44285dfa 2720 Double_t ssdflexboxwidth[kssdflexboxnumber];
2721 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2722 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2723 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2724 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2725 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2726 ///////////////////////
2727 // Setting the vertices
2728 ///////////////////////
2729 xmothervertex[0] = 0.0;
2730 xmothervertex[1] = xmothervertex[0];
2731 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2732 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2733 + ssdflexboxlength[4];
2734 xmothervertex[4] = xmothervertex[3];
2735 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2736 xmothervertex[6] = xmothervertex[5];
2737 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2738 xmothervertex[8] = xmothervertex[7];
2739 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2740 xmothervertex[10] = xmothervertex[9];
2741 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2742 xmothervertex[12] = xmothervertex[11];
2743 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2744 xmothervertex[14] = xmothervertex[13];
2745 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2746 xmothervertex[16] = xmothervertex[15];
2747 ymothervertex[0] = 0.0;
2748 ymothervertex[1] = fgkSSDFlexWidth[1];
2749 ymothervertex[2] = fgkSSDFlexWidth[0];
2750 ymothervertex[3] = ymothervertex[2];
2751 ymothervertex[4] = ymothervertex[0];
2752 ymothervertex[5] = ymothervertex[4];
2753 ymothervertex[6] = ssdflexboxwidth[2];
2754 ymothervertex[7] = ymothervertex[6];
2755 ymothervertex[8] = ymothervertex[0];
2756 ymothervertex[9] = ymothervertex[8];
2757 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2758 ymothervertex[11] = ymothervertex[10];
2759 ymothervertex[12] = ymothervertex[0];
2760 ymothervertex[13] = ymothervertex[12];
2761 ymothervertex[14] = ymothervertex[7];
2762 ymothervertex[15] = ymothervertex[14];
2763 ymothervertex[16] = ymothervertex[0];
2764 /////////////////////////////////////////////////////////////
2765 // First Mother Volume containing SSDFlex
2766 /////////////////////////////////////////////////////////////
2767 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2768 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2769 ymothervertex);
2770 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2771 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2772 TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2773 fSSDAir);
2774 /////////////////////////////////////////////////////////////
2775 // SSDFlex Layer Shapes
2776 /////////////////////////////////////////////////////////////
2777 for(Int_t i=0; i<kssdflexlayernumber; i++){
2778 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2779 ymothervertex);
2780 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2781 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2782 }
2783 /////////////////////////////////////
2784 // Setting Layers into Mother Volume
2785 /////////////////////////////////////
2786 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2787 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2788 fSSDKaptonFlexMedium};
2789 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2790 "AlFlexLay2","KaptonFlexLay2"};
2791 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2792 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2793 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2794 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2795 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2796 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2797 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2798 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2799 + fgkSSDFlexHeight[1]));
2800 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2801 }
6727e2db 2802 //ssdflexmother->CheckOverlaps(0.01);
bf210566 2803 return ssdflexmother;
d7599219 2804}
2805/////////////////////////////////////////////////////////////////////////////////
bf210566 2806TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2807 /////////////////////////////////////////////////////////////
2808 // Method generating SSD End Flex
d7599219 2809 /////////////////////////////////////////
bf210566 2810 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2811 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2812 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2813 * TMath::DegToRad()*ssdflexradiusmax
2814 - fgkSSDFlexLength[2]-TMath::Pi()
2815 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
2816 const Int_t knedges = 20;
2817 const Int_t karcnumber = 2;
2818 TVector3* vertexposition[karcnumber*(knedges+1)];
2819 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2820 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2821 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2822 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2823 - 90.0*TMath::DegToRad()};
2824 TVector3* referencetrans[karcnumber];
2825 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2826 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2827 radius[0]);
2828 referencetrans[1] = new TVector3(referencetrans[0]->X()
2829 + fgkSSDFlexLength[2],
2830 - fgkSSDStiffenerHeight);
2831for(Int_t i=0; i<karcnumber; i++){
2832 for(Int_t j=0; j<knedges+1; j++){
2833 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2834 radius[i]*SinD(angle[i]));
2835 angle[i] += deltangle[i]*(1.0-2.0*i);
2836 }
2837 }
2838 ///////////////////////
2839 // Setting the vertices
2840 ///////////////////////
2841 const Int_t kendflexlayernumber = 4;
2842 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2843 TVector3** vertex[kendflexlayernumber];
2844 for(Int_t i=0; i<kendflexlayernumber; i++)
2845 vertex[i] = new TVector3*[kendflexvertexnumber];
2846 TVector3* transvector[kendflexlayernumber+1];
2847 TVector3* deltatransvector = new TVector3();
2848 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2849 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2850 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2851 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2852 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2853 * CosD(fgkSSDFlexAngle),
2854 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2855 * SinD(fgkSSDFlexAngle),0.0);
2856 *transvector[i] = *transvector[i-1]+*deltatransvector;
2857 }
2858 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2859 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2860 for(Int_t i=0; i<karcnumber; i++){
2861 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2862 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2863 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2864 /radius[i];
2865 }
2866 }
2867 for(Int_t i=0; i<kendflexlayernumber; i++){
2868 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2869 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2870 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2871 if(j<(knedges+1)){
2872 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2873 vertexposition[j]->Y()*ratioradius[0][i+1]);
2874 vertex[i][j+2]->RotateZ(referenceangle[0]);
2875 *vertex[i][j+2] += *referencetrans[0];
2876 vertex[i][4*(knedges+1)-j+1] =
2877 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2878 vertexposition[j]->Y()*ratioradius[0][i]);
2879 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2880 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2881 }
2882 else{
2883
2884 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2885 vertexposition[j]->Y()*ratioradius[1][i+1]);
2886 vertex[i][j+2]->RotateZ(referenceangle[1]);
2887 *vertex[i][j+2] += *referencetrans[1];
2888 vertex[i][4*(knedges+1)-j+1] =
2889 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2890 vertexposition[j]->Y()*ratioradius[1][i]);
2891 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2892 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2893 }
2894 }
2895 }
44285dfa 2896 /////////////////////////////////////////////////////////////
bf210566 2897 // First Mother Volume containing SSDEndFlex
2898 /////////////////////////////////////////////////////////////
2899 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2900 Double_t xmothervertex[kendflexvertexnumber];
2901 Double_t ymothervertex[kendflexvertexnumber];
2902 xmothervertex[0] = vertex[0][0]->X();
2903 ymothervertex[0] = vertex[0][0]->Y();
2904 for(Int_t i=1; i<kendflexvertexnumber; i++){
2905 if(i<2*(knedges+1)+2){
2906 xmothervertex[i] = vertex[3][i]->X();
2907 ymothervertex[i] = vertex[3][i]->Y();
2908 }
2909 else{
2910 xmothervertex[i] = vertex[0][i]->X();
2911 ymothervertex[i] = vertex[0][i]->Y();
2912 }
2913 }
2914 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2915 xmothervertex,ymothervertex);
2916 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2917 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2918 TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2919 ssdendflexmothershape,fSSDAir);
2920 //////////////////////////////////////
2921 // End Flex TGeoXtru Layer Definition
2922 //////////////////////////////////////
2923 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2924 TGeoVolume* ssdendflex[kendflexlayernumber];
2925 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2926 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2927 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2928 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2929 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2930 fSSDKaptonFlexMedium};
2931 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2932 "AlEndFlexLay2","KaptonEndFlexLay2"};
2933 for(Int_t i=0; i<kendflexlayernumber; i++){
2934 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2935 xvertex[i][j] = vertex[i][j]->X();
2936 yvertex[i][j] = vertex[i][j]->Y();
2937 }
2938 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2939 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2940 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2941 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2942 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2943 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2944 ssdendflexmother->AddNode(ssdendflex[i],1);
2945 }
44285dfa 2946 /////////////////////////////////////////////////////////////
bf210566 2947 // Deallocating memory
44285dfa 2948 /////////////////////////////////////////////////////////////
bf210566 2949 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2950 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2951 for(Int_t i=0; i<kendflexlayernumber; i++){
2952 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2953 delete [] vertex[i];
2954 }
2955 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2956 delete deltatransvector;
44285dfa 2957 /////////////////////////////////////////////////////////////
6727e2db 2958 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 2959 return ssdendflexmother;
d7599219 2960}
9b0c60ab 2961///////////////////////////////////////////////////////////////////////////////
bf210566 2962TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 2963 /////////////////////////////////////////////////////////////
9b0c60ab 2964 // Method generating the Mounting Block
bf210566 2965 /////////////////////////////////////////////////////////////
9b0c60ab 2966 const Int_t kvertexnumber = 8;
2967 Double_t xvertex[kvertexnumber];
2968 Double_t yvertex[kvertexnumber];
2969 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2970 xvertex[1] = xvertex[0];
2971 xvertex[2] = -xvertex[0];
2972 xvertex[3] = xvertex[2];
2973 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2974 - fgkSSDMountingBlockLength[2]);
2975 xvertex[5] = xvertex[4];
2976 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2977 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2978 - fgkSSDMountingBlockScrewHoleRadius[0];
2979 xvertex[7] = xvertex[6];
2980 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
e21cdd03 2981 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]
2982 - fgkSSDModuleVerticalDisalignment;
9b0c60ab 2983 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2984 yvertex[2] = yvertex[1];
2985 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2986 yvertex[4] = yvertex[3];
2987 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2988 - fgkSSDMountingBlockHeight[0];
2989 yvertex[6] = yvertex[5];
2990 yvertex[7] = yvertex[0];
2991 ///////////////////////////////////////////////////////////////////////
2992 // TGeoXTru Volume definition for Mounting Block Part
2993 ///////////////////////////////////////////////////////////////////////
2994 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2995 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2996 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2997 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 2998 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 2999 ssdmountingblockshape,
3000 fSSDMountingBlockMedium);
3001 ssdmountingblock->SetLineColor(fColorG10);
3002 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
3003 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
3004 TGeoRotation* mountingblockrot = new TGeoRotation();
3005 mountingblockrot->SetAngles(90.,180.,-90.);
3006 mountingblockcombitrans->SetRotation(*mountingblockrot);
3007 /////////////////////////////////////////////////////////////
3008 // Generating the Mounting Block Screw Vertices
3009 /////////////////////////////////////////////////////////////
3010 const Int_t kscrewvertexnumber = 15;
3011 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
3012 - fgkSSDMountingBlockScrewHoleEdge)
3013 / fgkSSDMountingBlockScrewHoleRadius[0])
3014 * TMath::RadToDeg();
3015 Double_t phi0 = 90.+alpha;
3016 Double_t phi = 270.-2*alpha;
3017 Double_t deltaphi = phi/kscrewvertexnumber;
3018 TVector3* screwvertex[kscrewvertexnumber+1];
3019 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
3020 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
3021 *CosD(phi0+i*deltaphi),
3022 fgkSSDMountingBlockScrewHoleRadius[0]
3023 *SinD(phi0+i*deltaphi));
3024 Double_t xscrewvertex[kscrewvertexnumber+6];
3025 Double_t yscrewvertex[kscrewvertexnumber+6];
3026 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
3027 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
3028 - fgkSSDMountingBlockScrewHoleEdge);
3029 xscrewvertex[1] = xscrewvertex[0];
3030 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3031 xscrewvertex[2] = screwvertex[0]->X();
3032 yscrewvertex[2] = yscrewvertex[1];
3033 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
3034 xscrewvertex[i+3] = screwvertex[i]->X();
3035 yscrewvertex[i+3] = screwvertex[i]->Y();
3036 }
3037 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3038 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
3039 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
3040 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
3041 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
3042 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
3043 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
3044 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
3045 + fgkSSDMountingBlockHeight[2]);
3046 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
3047 ssdmountingblockscrewshape,
3048 fSSDMountingBlockMedium);
3049 ssdmountingblockscrew->SetLineColor(fColorG10);
3050 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
3051 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
3052 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3053 - yscrewvertex[1],
3054 0.5*fgkSSDMountingBlockHeight[0]
3055 - fgkSSDMountingBlockHeight[2]
3056 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3057 + fgkSSDMountingBlockHeight[2]
3058 - yvertex[0]));
3059 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3060 -0.5*fgkSSDMountingBlockScrewHoleEdge,
3061 yscrewvertex[1]
3062 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3063 +fgkSSDMountingBlockHeight[2]
3064 -yvertex[0]));
3065 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3066 yscrewvertex[1],
3067 - 0.5*fgkSSDMountingBlockHeight[0]
3068 + fgkSSDMountingBlockHeight[2]
3069 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3070 + fgkSSDMountingBlockHeight[2]
3071 - yvertex[0]));
3072 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3073 yscrewvertex[1],
3074 - yscrewvertex[1]
3075 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3076 + fgkSSDMountingBlockHeight[2]
3077 - yvertex[0]));
3078 TGeoRotation* ssdmountingblockscrewrot[4];
3079 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3080 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3081 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3082 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3083 for(Int_t i=1; i<4; i++)
3084 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3085 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3086 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3087 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3088 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3089 + xvertex[0],yscrewvertex[1]
3090 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3091 + fgkSSDMountingBlockHeight[2]
3092 - yvertex[0]),0.);
3093 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3094 for(Int_t i=0; i<4; i++){
3095 ssdmountingblockscrewmatrix[i] =
3096 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3097 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3098 }
3099 ///////////////////////////////////////////////////////////////////////
3100 // TGeoXtru for Mother Volume
3101 ///////////////////////////////////////////////////////////////////////
3102 const Int_t kvertexmothernumber = 12;
3103 Double_t xmothervertex[kvertexmothernumber];
3104 Double_t ymothervertex[kvertexmothernumber];
3105 for(Int_t i=0; i<6; i++){
3106 xmothervertex[i] = xvertex[i];
3107 ymothervertex[i] = yvertex[i];
3108 }
3109 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3110 ymothervertex[6] = ymothervertex[5];
3111 xmothervertex[7] = xmothervertex[6];
3112 ymothervertex[7] = ymothervertex[4];
3113 xmothervertex[8] = xmothervertex[7]
3114 + 0.5*(fgkSSDMountingBlockLength[1]
3115 - fgkSSDMountingBlockLength[2]);
3116 ymothervertex[8] = ymothervertex[4];
3117 xmothervertex[9] = xmothervertex[8];
3118 ymothervertex[9] = ymothervertex[2];
3119 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3120 ymothervertex[10] = ymothervertex[1];
3121 xmothervertex[11] = xmothervertex[10];
3122 ymothervertex[11] = ymothervertex[0];
3123 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3124 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3125 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3126 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3127 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3128 ssdmountingblockmothershape,
3129 fSSDAir);
3130 /////////////////////////////////////////////////////////////
3131 // Placing the Volumes into Mother Volume
3132 /////////////////////////////////////////////////////////////
3133 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3134 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3135 for(Int_t i=0; i<4; i++)
3136 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3137 ssdmountingblockscrewmatrix[i]);
3138 /////////////////////////////////////////////////////////////
3139 // Deallocating memory
3140 /////////////////////////////////////////////////////////////
3141 delete mountingblockrot;
3142 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3143 delete ssdmountingblockglobalrot;
3144 delete ssdmountingblockglobaltrans;
3145 /////////////////////////////////////////////////////////////
3146 return ssdmountingblockmother;
3147}
3148///////////////////////////////////////////////////////////////////////////////
3149 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3150 /////////////////////////////////////////////////////////////
3151 // Method generating the Mounting Block Clip
3152 /////////////////////////////////////////////////////////////
3153 const Int_t kmothervertexnumber = 10;
3154 Double_t xmothervertex[kmothervertexnumber];
3155 Double_t ymothervertex[kmothervertexnumber];
3156 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3157 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3158 xmothervertex[1] = xmothervertex[0];
3159 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3160 - fgkMountingBlockClibScrewRadius);
3161 xmothervertex[3] = xmothervertex[2];
3162 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3163 xmothervertex[5] = xmothervertex[4];
3164 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3165 xmothervertex[7] = xmothervertex[6];
3166 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3167 xmothervertex[9] = xmothervertex[8];
3168 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
e21cdd03 3169 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]
3170 - fgkSSDModuleVerticalDisalignment;
9b0c60ab 3171 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3172 ymothervertex[2] = ymothervertex[1];
3173 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3174 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3175 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3176 ymothervertex[4] = ymothervertex[3];
3177 ymothervertex[5] = ymothervertex[2];
3178 ymothervertex[6] = ymothervertex[5];
3179 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3180 ymothervertex[8] = ymothervertex[7];
3181 ymothervertex[9] = ymothervertex[0];
3182 ///////////////////////////////////////////////////////////////////////
3183 // TGeoXTru Volume definition for Mounting Block Clip Part
3184 ///////////////////////////////////////////////////////////////////////
3185 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3186 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3187 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3188 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3189 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3190 ssdmountingblockclipshape,fSSDAir);
3191 ssdmountingblockclip->SetLineColor(4);
3192 ///////////////////////////////////////////////////////////////////////
3193 // TGeoXTru Volume definition for Clip
3194 ///////////////////////////////////////////////////////////////////////
3195 const Int_t kclipvertexnumber = 6;
3196 Double_t xclipvertex[kclipvertexnumber];
3197 Double_t yclipvertex[kclipvertexnumber];
3198 xclipvertex[0] = xmothervertex[0];
3199 xclipvertex[1] = xclipvertex[0];
3200 xclipvertex[2] = xmothervertex[6];
3201 xclipvertex[3] = xclipvertex[2];
3202 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3203 xclipvertex[5] = xclipvertex[4];
3204 yclipvertex[0] = ymothervertex[0];
3205 yclipvertex[1] = ymothervertex[1];
3206 yclipvertex[2] = yclipvertex[1];
3207 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3208 yclipvertex[4] = yclipvertex[3];
3209 yclipvertex[5] = yclipvertex[0];
3210 TGeoXtru* clipshape = new TGeoXtru(2);
3211 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3212 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3213 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3214 + fgkMountingBlockClibWidth);
3215 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3216 clip->SetLineColor(18);
3217 ///////////////////////////////////////////////////////////////////////
3218 // Ladder Support Piece
3219 ///////////////////////////////////////////////////////////////////////
3220 const Int_t ksupportvertexnumber = 4;
3221 Double_t xsupportvertex[ksupportvertexnumber];
3222 Double_t ysupportvertex[ksupportvertexnumber];
3223 xsupportvertex[0] = xclipvertex[5];
3224 xsupportvertex[1] = xsupportvertex[0];
3225 xsupportvertex[2] = xmothervertex[9];
3226 xsupportvertex[3] = xsupportvertex[2];
3227 ysupportvertex[0] = yclipvertex[0];
3228 ysupportvertex[1] = yclipvertex[3];
3229 ysupportvertex[2] = ysupportvertex[1];
3230 ysupportvertex[3] = ysupportvertex[0];
3231 TGeoXtru* supportshape = new TGeoXtru(2);
3232 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3233 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3234 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3235 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3236 support->SetLineColor(9);
3237 ///////////////////////////////////////////////////////////////////////
3238 // TGeoXTru Volume definition for Screw
3239 ///////////////////////////////////////////////////////////////////////
3240 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3241 0.5*fgkMountingBlockClibScrewRadius};
3242 Int_t edgesnumber[2] = {50,6};
3243 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3244 +0.5*(ymothervertex[3]-ymothervertex[2])};
3245 TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3246 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3247 clipscrew->SetLineColor(12);
3248 TGeoRotation* screwrot = new TGeoRotation();
3249 screwrot->SetAngles(0.,90.,0.);
3250 TGeoTranslation* screwtrans = new TGeoTranslation();
3251 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3252 0.5*(ymothervertex[3]+ymothervertex[2]),
3253 0.5*fgkSSDMountingBlockWidth+
3254 -0.5*fgkMountingBlockSupportWidth[0]);
3255 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3256 ///////////////////////////////////////////////////////////////////////
3257 // Placing the Volumes
3258 ///////////////////////////////////////////////////////////////////////
3259 ssdmountingblockclip->AddNode(clip,1);
3260 ssdmountingblockclip->AddNode(support,1);
3261 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3262 /////////////////////////////////////////////////////////////
3263 // Deallocating memory
3264 /////////////////////////////////////////////////////////////
3265 delete screwtrans;
3266 delete screwrot;
3267 /////////////////////////////////////////////////////////////
3268 return ssdmountingblockclip;
d7599219 3269}
bf210566 3270///////////////////////////////////////////////////////////////////////////////
3271TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
44285dfa 3272 /////////////////////////////////////////////////////////////
bf210566 3273 // Method generating the Cooling Tube
44285dfa 3274 /////////////////////////////////////////////////////////////
bf210566 3275 TGeoTube** coolingtubeshape[fgkcoolingtubenumber];
3276 for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtubeshape[i] =
3277 new TGeoTube*[2];
9b0c60ab 3278 // Ladder Cooling Tubes
bf210566 3279 coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3280 0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3281 - 2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth));
3282 coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3283 coolingtubeshape[0][0]->GetDz());
3284 coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3285 0.5*(fgkSSDModuleStiffenerPosition[1]
3286 - fgkSSDSensorOverlap));
3287 coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3288 coolingtubeshape[1][0]->GetDz());
3289 coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3290 0.5*fgkSSDModuleStiffenerPosition[1]);
3291 coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3292 coolingtubeshape[2][0]->GetDz());
9b0c60ab 3293 // End Ladder Cooling Tubes
3294 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3295 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3296 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3297 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3298 0.50 * (fgkEndLadderMountingBlockPosition[0]
3299 - fgkendladdercoolingsupportdistance[0]));
3300 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3301 endladdercoolingtubeshape[0][0]->GetDz());
3302 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3303 0.50 * (fgkendladdercoolingsupportdistance[0]
3304 + fgkendladdercoolingsupportdistance[1]
3305 - fgkCoolingTubeSupportWidth));
3306 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3307 endladdercoolingtubeshape[1][0]->GetDz());
3308 endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3309 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
3310 - fgkEndLadderMountingBlockPosition[0]
3311 - fgkendladdercoolingsupportdistance[1]
3312 - fgkCoolingTubeSupportWidth));
3313 endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3314 endladdercoolingtubeshape[2][0]->GetDz());
3315 endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3316 0.50 * (fgkMountingBlockToSensorSupport
3317 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
3318 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
3319 + fgkSSDSensorOverlap
3320 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
3321 - fgkendladdercoolingsupportdistance[2]
3322 - fgkEndLadderMountingBlockPosition[1]
3323 - fgkCoolingTubeSupportWidth));
3324 endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3325 endladdercoolingtubeshape[3][0]->GetDz());
3326 endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3327 0.50 * fgkendladdercoolingsupportdistance[2]);
3328 endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3329 endladdercoolingtubeshape[4][0]->GetDz());
3330 // Ladder Cooling Tubes
bf210566 3331 TGeoVolume** coolingtube[fgkcoolingtubenumber];
3332 for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtube[i] =
3333 new TGeoVolume*[2];
3334 coolingtube[0][0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0][0],
3335 fSSDCoolingTubePhynox);
3336 coolingtube[0][1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[0][1],
3337 fSSDCoolingTubeWater);
3338 coolingtube[1][0] = new TGeoVolume("OuterCoolingTube2",coolingtubeshape[1][0],
3339 fSSDCoolingTubePhynox);
3340 coolingtube[1][1] = new TGeoVolume("InnerCoolingTube2",coolingtubeshape[1][1],
3341 fSSDCoolingTubeWater);
3342 coolingtube[2][0] = new TGeoVolume("OuterCoolingTube3",coolingtubeshape[2][0],
3343 fSSDCoolingTubePhynox);
3344 coolingtube[2][1] = new TGeoVolume("InnerCoolingTube3",coolingtubeshape[2][1],
3345 fSSDCoolingTubeWater);
3346 for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3347 coolingtube[i][0]->SetLineColor(fColorPhynox);
3348 coolingtube[i][1]->SetLineColor(fColorWater);
3349 }
9b0c60ab 3350 // End Ladder Cooling Tubes
3351 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3352 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3353 endladdercoolingtube[i] = new TGeoVolume*[2];
3354 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3355 endladdercoolingtubeshape[0][0],
3356 fSSDCoolingTubePhynox);
3357 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3358 endladdercoolingtubeshape[0][1],
3359 fSSDCoolingTubeWater);
3360 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3361 endladdercoolingtubeshape[1][0],
3362 fSSDCoolingTubePhynox);
3363 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3364 endladdercoolingtubeshape[1][1],
3365 fSSDCoolingTubeWater);
3366 endladdercoolingtube[2][0] = new TGeoVolume("OuterEndLadderCoolingTube3",
3367 endladdercoolingtubeshape[2][0],
3368 fSSDCoolingTubePhynox);
3369 endladdercoolingtube[2][1] = new TGeoVolume("InnerEndlLadderCoolingTube3",
3370 endladdercoolingtubeshape[2][1],
3371 fSSDCoolingTubeWater);
3372 endladdercoolingtube[3][0] = new TGeoVolume("OuterEndLadderCoolingTube4",
3373 endladdercoolingtubeshape[3][0],
3374 fSSDCoolingTubePhynox);
3375 endladdercoolingtube[3][1] = new TGeoVolume("InnerEndlLadderCoolingTube4",
3376 endladdercoolingtubeshape[3][1],
3377 fSSDCoolingTubeWater);
3378 endladdercoolingtube[4][0] = new TGeoVolume("OuterEndLadderCoolingTube5",
3379 endladdercoolingtubeshape[4][0],
3380 fSSDCoolingTubePhynox);
3381 endladdercoolingtube[4][1] = new TGeoVolume("InnerEndlLadderCoolingTube5",
3382 endladdercoolingtubeshape[4][1],
3383 fSSDCoolingTubeWater);
3384 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3385 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3386 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3387 }
bf210566 3388 /////////////////////////////////////////////////////////////
3389 // Virtual Volume containing Cooling Tubes
3390 /////////////////////////////////////////////////////////////
9b0c60ab 3391 // Ladder Cooling Tubes
bf210566 3392 TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber];
3393 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
3394 virtualcoolingtubeshape[i] = new TGeoTube(coolingtubeshape[i][1]->GetRmin(),
3395 coolingtubeshape[i][0]->GetRmax(),
3396 coolingtubeshape[i][0]->GetDz());
3397 TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber];
3398 virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0],
3399 fSSDAir);
3400 virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1],
3401 fSSDAir);
3402 virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2],
3403 fSSDAir);
9b0c60ab 3404 // End Ladder Cooling Tubes
3405 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3406 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3407 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3408 endladdercoolingtubeshape[i][0]->GetRmax(),
3409 endladdercoolingtubeshape[i][0]->GetDz());
3410 TGeoVolume* endladdervirtualcoolingtube[fgkendladdercoolingtubenumber];
3411 endladdervirtualcoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3412 endladdervirtualcoolingtubeshape[0],
3413 fSSDAir);
3414 endladdervirtualcoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3415 endladdervirtualcoolingtubeshape[1],
3416 fSSDAir);
3417 endladdervirtualcoolingtube[2] = new TGeoVolume("EndLadderCoolingTube3",
3418 endladdervirtualcoolingtubeshape[2],
3419 fSSDAir);
3420 endladdervirtualcoolingtube[3] = new TGeoVolume("EndLadderCoolingTube4",
3421 endladdervirtualcoolingtubeshape[3],
3422 fSSDAir);
3423 endladdervirtualcoolingtube[4] = new TGeoVolume("EndLadderCoolingTube5",
3424 endladdervirtualcoolingtubeshape[4],
3425 fSSDAir);
bf210566 3426 TList* coolingtubelist = new TList();
3427 for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3428 virtualcoolingtube[i]->AddNode(coolingtube[i][0],1);
3429 virtualcoolingtube[i]->AddNode(coolingtube[i][1],1);
3430 coolingtubelist->Add(virtualcoolingtube[i]);
d7599219 3431 }
9b0c60ab 3432 endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3433 endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3434 coolingtubelist->Add(endladdervirtualcoolingtube[0]);
3435 endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3436 endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3437 coolingtubelist->Add(endladdervirtualcoolingtube[1]);
3438 endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][0],1);
3439 endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][1],1);
3440 coolingtubelist->Add(endladdervirtualcoolingtube[2]);
3441 endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][0],1);
3442 endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][1],1);
3443 coolingtubelist->Add(endladdervirtualcoolingtube[3]);
3444 endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][0],1);
3445 endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][1],1);
3446 coolingtubelist->Add(endladdervirtualcoolingtube[4]);
bf210566 3447 return coolingtubelist;
d7599219 3448}
bf210566 3449///////////////////////////////////////////////////////////////////////////////
3450TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3451 /////////////////////////////////////////////////////////////
bf210566 3452 // Method generating SSD Cooling Block
44285dfa 3453 /////////////////////////////////////////////////////////////
bf210566 3454 const Int_t kvertexnumber = 8;
3455 ///////////////////////////////////////
3456 // Vertex Positioning for TGeoXTru
3457 ///////////////////////////////////////
3458 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3459 vertexposition[0] = new TVector3(0.0,0.0);
3460 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3461 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3462 vertexposition[1]->Y());
3463 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3464 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3465 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3466 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3467 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3468 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3469 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3470 - fgkSSDCoolingBlockHoleLength[0]
3471 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3472 fgkSSDCoolingBlockHeight[0]
3473 - fgkSSDCoolingBlockHoleRadius[1],
3474 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3475 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3476 - fgkSSDCoolingBlockHoleLength[0]),
3477 vertexposition[6]->Y());
3478 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3479 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3480 Double_t phi = 180.-alpha;
3481 Double_t psi = 180.+2.*alpha;
3482 Double_t deltapsi = psi/nedges;
3483 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3484 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3485 fgkSSDCoolingBlockHoleCenter);
3486 for(Int_t i=0; i<nedges+1; i++){
3487 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3488 radius*SinD(phi+i*deltapsi));
3489 *vertexposition[kvertexnumber+i] += (*transvector);
3490 }
3491 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3492 for(Int_t i=0; i<kvertexnumber; i++)
3493 vertexposition[kvertexnumber+nedges+1+i] =
3494 GetReflection(vertexposition[kvertexnumber-1-i],param);
3495 ///////////////////////////////////////////////////////////////////////
3496 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3497 ///////////////////////////////////////////////////////////////////////
3498 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3499 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3500 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3501 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3502 xvertexpoints[i] = vertexposition[i]->X();
3503 yvertexpoints[i] = vertexposition[i]->Y();
3504 }
3505 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3506 yvertexpoints);
3507 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3508 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3509 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3510 ssdcoolingblockshape,
3511 fSSDAlCoolBlockMedium);
3512 ssdcoolingblock->SetLineColor(fColorAl);
3513 /////////////////////////////////////////////////////////////
3514 // Deallocating memory
3515 /////////////////////////////////////////////////////////////
3516 delete [] vertexposition;
3517 delete xvertexpoints;
3518 delete yvertexpoints;
3519 /////////////////////////////////////////////////////////////
3520 return ssdcoolingblock;
3521}
3522/////////////////////////////////////////////////////////////////////////////////
3523TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
d7599219 3524 ///////////////////////////////////////////////////////
bf210566 3525 const Int_t kssdchipcablesnumber = 2;
3526 const Int_t kssdchipcableslaynumber = 2;
3527 const Int_t kvertexnumber = 4*(nedges+1)+4;
3528 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3529 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3530 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
3531 - fgkSSDChipCablesHeight[0]
3532 - fgkSSDChipCablesHeight[1]);
3533 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3534 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3535 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3536 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3537 - ssdchipcablesradius[0]
3538 - fgkSSDChipCablesWidth[1]
3539 - fgkSSDChipCablesWidth[2]);
3540 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3541 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3542 + fgkSSDChipCablesHeight[1]
3543 + fgkSSDSensorHeight);
d7599219 3544 ///////////////////////////////////////////////////////
bf210566 3545 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3546 ///////////////////////////////////////////////////////
3547 TVector3** vertexposition[kssdchipcableslaynumber];
3548 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3549 new TVector3*[4*(nedges+1)+4];
3550 Double_t ratio[4];
3551 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3552 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3553 / ssdchipcablesradius[0];
3554 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3555 / ssdchipcablesradius[0];
3556 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3557 + fgkSSDChipCablesHeight[1])
3558 / ssdchipcablesradius[0];
3559 Double_t phi = 180.;
3560 Double_t deltaphi = 180./nedges;
3561 Double_t angle = 0.0;
3562 Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3563 Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3564 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3565 xvertexpoints[i] = new Double_t[kvertexnumber];
3566 yvertexpoints[i] = new Double_t[kvertexnumber];
3567 }
3568 TVector3* vertex = new TVector3();
3569 TVector3* transvector[kssdchipcableslaynumber];
3570 transvector[0] = new TVector3(fgkSSDChipWidth,
3571 SSDChipCablesHeigth-ssdchipcablesradius[0]);
3572 transvector[1] = new TVector3();
3573 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
3574 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
3575 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
3576 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3577 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3578 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3579 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3580 transvector[1]->SetY(ssdchipcablesradius[0]
3581 + fgkSSDChipCablesHeight[0]
3582 + fgkSSDChipCablesHeight[1]);
3583 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3584 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
3585 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
3586 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
3587 - i*fgkSSDChipCablesHeight[0]);
3588 vertexposition[i][2*(nedges+1)+2] =
3589 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3590 + fgkSSDChipCablesWidth[1]
3591 + fgkSSDChipCablesWidth[2],
3592 ((1.-i)*fgkSSDChipCablesHeight[i]
3593 + fgkSSDChipCablesHeight[1]));
3594 vertexposition[i][2*(nedges+1)+3] =
3595 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3596 vertexposition[i][2*(nedges+1)+2]->Y()
3597 - fgkSSDChipCablesHeight[i]);
3598 for(Int_t j=0; j<nedges+1; j++){
3599 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3600 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3601 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3602 vertexposition[0][(nedges+1)*i+j+2] =
3603 new TVector3(*vertex+*transvector[i]);
3604 vertexposition[1][(nedges+1)*i+j+2] =
3605 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3606 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3607 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3608 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3609 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3610 new TVector3(vertex->X()*ratio[2*i+1]
3611 + transvector[i]->X(),
3612 vertex->Y()*ratio[2*i+1]
3613 + transvector[i]->Y());
3614 }
3615 }
3616 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3617 for(Int_t j=0; j<kvertexnumber; j++){
3618 xvertexpoints[i][j] = vertexposition[i][j]->X();
3619 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3620 }
3621 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3622 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3623 xvertexpoints[i],yvertexpoints[i]);
3624 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3625 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3626 ssdchipcable[kssdchipcablesnumber*k+i] =
3627 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3628 ssdchipcableshape[kssdchipcablesnumber*k+i],
3629 (kssdchipcablesnumber*k+i)%2==0?
3630 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3631 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3632 }
3633 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3634 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3635 }
44285dfa 3636 /////////////////////////////////////////////////////////////
bf210566 3637 // Mother Volume definition
3638 /////////////////////////////////////////////////////////////
3639 Double_t ssdchipseparation = fgkSSDSensorLength
3640 - 2.*fgkSSDModuleStiffenerPosition[1]
3641 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3642 - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
3643 Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth};
3644 Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0]
3645 +fgkSSDChipCablesWidth[1]
3646 +fgkSSDChipCablesWidth[2]);
3647 Double_t dy = fgkSSDChipCablesLength[1];
3648 Double_t dz = SSDChipCablesHeigth;
3649 TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
3650 TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother",
3651 ssdchipcablesmotherbox,fSSDAir);
3652 /////////////////////////////////////////////////////////////
3653 // Rotation and Translation Definition for positioning
3654 /////////////////////////////////////////////////////////////
3655 TGeoRotation* ssdchipcablesrot[5];
3656 ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
3657 ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
3658 ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
3659 ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
3660 ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
3661 TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,
3662 0.,0.,ssdchipcablesrot[2]);
3663 ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]);
3664 ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]);
3665 ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans);
3666 ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans);
3667 /////////////////////////////////////////////////////////////
3668 // Deallocating memory
3669 /////////////////////////////////////////////////////////////
3670 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3671 delete [] xvertexpoints[i];
3672 delete [] yvertexpoints[i];
3673 }
3674 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3675 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3676 delete vertex;
3677 delete ssdchipcablesrot[0];
3678 delete ssdchipcablesrot[1];
3679 delete ssdchipcablesrot[3];
3680 /////////////////////////////////////////////////////////////
3681 return ssdchipcablesmother;
d7599219 3682}
bf210566 3683///////////////////////////////////////////////////////////////////////////////
3684TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
3685 /////////////////////////////////////////////////////////////
3686 // SSD Chip Assembly
3687 /////////////////////////////////////////////////////////////
3688 TGeoVolume* ssdchipassembly = GetSSDChips();
3689 TList* ssdchipsystemlist = new TList();
e21cdd03 3690// const Int_t knedges = 20;
3691 const Int_t knedges = 5;
bf210566 3692 const Int_t kchipsystemnumber = 2;
3693 /////////////////////////////////////////////////////////////
3694 // Mother Volume containing SSDChipSystem
3695 /////////////////////////////////////////////////////////////
3696 TGeoXtru* chipsystemothershape[kchipsystemnumber];
3697 for(Int_t i=0; i<kchipsystemnumber; i++) chipsystemothershape[i] = new TGeoXtru(2);
3698 const Int_t kmothervertexnumber = 12;
3699 Double_t xmothervertex[kchipsystemnumber][kmothervertexnumber];
3700 Double_t ymothervertex[kchipsystemnumber][kmothervertexnumber];
3701 Double_t ssdchipcablesradius[kchipsystemnumber];
3702 Double_t ssdchipseparation = fgkSSDSensorLength
3703 - 2.*fgkSSDModuleStiffenerPosition[1]
3704 - 2.*(fgkSSDStiffenerWidth
3705 - fgkSSDStiffenerToChipDist-0.5*fgkSSDChipWidth);
3706 for(Int_t i=0; i<kchipsystemnumber; i++)
3707 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
3708 - fgkSSDChipCablesHeight[0]
3709 - fgkSSDChipCablesHeight[1]);
3710 ///////////////////////
3711 // Setting the vertices
3712 ///////////////////////
3713 xmothervertex[0][0] = -0.5*fgkSSDChipCablesLength[1];
3714 xmothervertex[0][1] = xmothervertex[0][0];
3715 xmothervertex[0][2] = (fgkSSDChipNumber-1)*(fgkSSDChipLength
3716 + fgkSSDChipSeparationLength)+0.5*fgkSSDChipCablesLength[1];
3717 xmothervertex[0][3] = xmothervertex[0][2];
3718 xmothervertex[0][4] = 0.5*fgkSSDChipCablesLength[1];
3719 xmothervertex[0][5] = xmothervertex[0][4];
3720 xmothervertex[0][6] = xmothervertex[0][2]-0.5*fgkSSDChipCablesLength[1];
3721 xmothervertex[0][7] = xmothervertex[0][6];
3722 xmothervertex[0][8] = 0.0;
3723 xmothervertex[0][9] = xmothervertex[0][8];
3724 xmothervertex[0][10] = xmothervertex[0][4];
3725 xmothervertex[0][11] = xmothervertex[0][10];
3726 for(Int_t i=0; i<kmothervertexnumber; i++)
3727 xmothervertex[1][i] = xmothervertex[0][i];
3728 for(Int_t i=0; i<kchipsystemnumber; i++){
3729 ymothervertex[i][0] = -0.5*fgkSSDChipWidth-ssdchipcablesradius[i]
3730 - fgkSSDChipCablesWidth[1]-fgkSSDChipCablesWidth[2];
3731 ymothervertex[i][1] = ssdchipseparation-ymothervertex[i][0];
3732 ymothervertex[i][2] = ymothervertex[i][1];
3733 ymothervertex[i][3] = ymothervertex[i][0];
3734 ymothervertex[i][4] = ymothervertex[i][0];
3735 ymothervertex[i][5] = 0.5*fgkSSDChipWidth;
3736 ymothervertex[i][6] = ymothervertex[i][5];
3737 ymothervertex[i][7] = ssdchipseparation-0.5*fgkSSDChipWidth;
3738 ymothervertex[i][8] = ymothervertex[i][7];
3739 ymothervertex[i][9] = ymothervertex[i][5];
3740 ymothervertex[i][10] = ymothervertex[i][5];
3741 ymothervertex[i][11] = ymothervertex[i][4];
3742 }
3743 //////////////////////////////////////////////////////////
3744 TGeoVolume* chipsystemother[kchipsystemnumber];
3745 const char* chipsytemothername[kchipsystemnumber] =
3746 {"SSDChipSytemother1","SSDChipSytemother2"};
3747 for(Int_t i=0; i<kchipsystemnumber; i++){
3748 chipsystemothershape[i]->DefinePolygon(kmothervertexnumber,
3749 xmothervertex[i],ymothervertex[i]);
3750 chipsystemothershape[i]->DefineSection(0,-fgkSSDChipCablesHeight[i+2]
3751 -0.5*fgkSSDChipHeight);
3752 chipsystemothershape[i]->DefineSection(1,0.5*fgkSSDChipHeight);
3753 chipsystemother[i] = new TGeoVolume(chipsytemothername[i],
3754 chipsystemothershape[i],fSSDAir);
3755 }
44285dfa 3756 /////////////////////////////////////////////////////////////
bf210566 3757 // SSD Chip Cables
3758 /////////////////////////////////////////////////////////////
3759 TGeoVolume* ssdchipcables[kchipsystemnumber];
3760 TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
3761 TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
3762 TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
3763 //////////////////
3764 for(Int_t i=0; i<kchipsystemnumber; i++){
3765 ssdchipcables[i] =
3766 GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
3767 ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
3768 ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
3769 ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
3770 }
3771 for(Int_t i=0; i<kchipsystemnumber; i++){
3772 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3773 ssdchipcablestrans[i][j] = new TGeoTranslation();
3774 ssdchipcablesrot[i][j] = new TGeoRotation();
3775 ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
3776 ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
3777 ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
3778 + fgkSSDChipSeparationLength),
3779 0.5*fgkSSDChipWidth,
3780 - 0.5*fgkSSDChipHeight
3781 - fgkSSDChipCablesHeight[i+2]);
3782 ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
3783 ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
3784 chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
bf210566 3785 }
3786 chipsystemother[i]->AddNode(ssdchipassembly,i+1);
e21cdd03 3787 ssdchipsystemlist->Add(chipsystemother[i]);
bf210566 3788 }
3789 /////////////////////////////////////////////////////////////
3790 // Deallocating memory
3791 /////////////////////////////////////////////////////////////
3792 for(Int_t i=0; i<kchipsystemnumber; i++){
3793 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3794 delete ssdchipcablesrot[i][j];
3795 delete ssdchipcablestrans[i][j];
3796 }
3797 delete ssdchipcablesrot[i];
3798 delete ssdchipcablestrans[i];
3799 }
3800 /////////////////////////////////////////////////////////////
3801 return ssdchipsystemlist;
d7599219 3802}
bf210566 3803///////////////////////////////////////////////////////////////////////////////
3804TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
44285dfa 3805 /////////////////////////////////////////////////////////////
bf210566 3806 // SSD Chip Assembly Generation
3807 /////////////////////////////////////////////////////////////
3808 const Int_t kssdchiprownumber = 2;
3809 TGeoBBox* ssdchipcompshape[2];
3810 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3811 0.5*fgkSSDChipLength,
3812 0.5*fgkSSDChipWidth,
3813 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3814 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3815 0.5*fgkSSDChipLength,
3816 0.5*fgkSSDChipWidth,
3817 0.5*fgkSSDChipGlueHeight);
3818 TGeoVolume* ssdchipcomp[2];
3819 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3820 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3821 fSSDChipGlueMedium);
3822 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3823 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3824 TGeoTranslation* ssdchipcomptrans[2];
3825 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3826 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3827 /////////////////////////////////////////////////////////////
3828 // Virtual Volume containing SSDChip
3829 /////////////////////////////////////////////////////////////
3830 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3831 0.5*fgkSSDChipWidth,
3832 0.5*fgkSSDChipHeight);
e21cdd03 3833 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
bf210566 3834 /////////////////////////////////////////////////////////////
3835 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3836 Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
3837 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3838 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3839 - 0.5*fgkSSDChipWidth)};
3840 /////////////////////////////////////////////////////////////
3841 // Virtual Volume containing SSDChipAssembly
3842 /////////////////////////////////////////////////////////////
3843 TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
3844 const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
3845 Double_t xmothervertex[kssdmothervertexnumber];
3846 Double_t ymothervertex[kssdmothervertexnumber];
3847 ///////////////////////
3848 // Setting the vertices
3849 ///////////////////////
3850 xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
3851 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
3852 - ymothervertex[0];
3853 xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
3854 ymothervertex[2] = ymothervertex[1];
3855 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
3856 xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
3857 ymothervertex[4] = ymothervertex[0];
3858 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
3859 xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
3860 + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
3861 ymothervertex[6] = ymothervertex[5];
3862 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
3863 - fgkSSDChipWidth;
3864 xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3865 ymothervertex[8] = ymothervertex[7];
3866 xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3867 ymothervertex[9] = ymothervertex[6];
3868 xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
3869 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
3870 //////////////////////////////////////////////////////////
3871 ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
3872 xmothervertex,ymothervertex);
3873 ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
3874 ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
3875 TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
3876 ssdchipmothershape,fSSDAir);
3877 /////////////////////////////////////////////////////////////
3878 for(Int_t i=0; i<kssdchiprownumber; i++)
3879 for(Int_t j=0; j<fgkSSDChipNumber; j++)
3880 ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
3881 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
3882 return ssdchipmother;
d7599219 3883}
bf210566 3884/////////////////////////////////////////////////////////////////////////////////
3885TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3886 /////////////////////////////////////////////////////////////
bf210566 3887 // Method returning a List containing pointers to Ladder Cable Volumes
44285dfa 3888 /////////////////////////////////////////////////////////////
bf210566 3889 const Int_t kladdercablesegmentnumber = 2;
3890 /////////////////////////////////////////
3891 // LadderSegmentBBox Volume
3892 /////////////////////////////////////////
3893 TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
3894 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3895 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3896 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3897 new TGeoBBox(laddercablesegmentbboxshapename[i],
3898 0.5*fgkSSDFlexWidth[0],
3899 0.5*fgkSSDLadderCableWidth,
3900 0.5*fgkSSDFlexHeight[i]);
3901 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3902 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3903 TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3904 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3905 laddercablesegmentbbox[i] =
3906 new TGeoVolume(laddercablesegmentbboxname[i],
3907 laddercablesegmentbboxshape[i],
3908 (i==0?fSSDAlTraceLadderCableMedium:
3909 fSSDKaptonLadderCableMedium));
3910 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3911 fColorPolyhamide);
3912 }
3913 TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
3914 laddercablesegmentbboxtrans[0] =
3915 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3916 0.5*fgkSSDFlexWidth[0],
3917 0.5*fgkSSDLadderCableWidth,
3918 0.5*fgkSSDFlexHeight[0]);
3919 laddercablesegmentbboxtrans[1] =
3920 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3921 0.5*fgkSSDFlexWidth[0],
3922 0.5*fgkSSDLadderCableWidth,
3923 fgkSSDFlexHeight[0]
3924 +0.5*fgkSSDFlexHeight[1]);
3925 TGeoVolume* laddercablesegmentbboxassembly =
3926 new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
3927 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3928 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3929 laddercablesegmentbboxtrans[i]);
3930/////////////////////////////////////////
3931// LadderSegmentArb8 Volume
3932/////////////////////////////////////////
3933 const Int_t kvertexnumber = 4;
3934 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3935 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3936 new TVector3*[kvertexnumber];
3937//Shape Vertex Positioning
3938 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3939 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3940 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3941 i*fgkSSDFlexHeight[0]);
3942 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3943 + fgkSSDFlexHeight[1]
3944 + i*fgkSSDFlexHeight[0]);
3945 laddercablesegmentvertexposition[i][3] =
3946 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3947 laddercablesegmentvertexposition[i][2]->Y());
3948 }
3949 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3950 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3951 char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3952 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3953 TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3954 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3955 GetArbShape(laddercablesegmentvertexposition[i],
3956 laddercablesegmentwidth[i],
3957 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3958 laddercablesegmentarbshapename[i]);
3959 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3960 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
3961 TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3962 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3963 laddercablesegmentarb[i] =
3964 new TGeoVolume(laddercablesegmentarbname[i],
3965 laddercablesegmentarbshape[i],
3966 (i==0?fSSDAlTraceLadderCableMedium:
3967 fSSDKaptonLadderCableMedium));
3968 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3969 fColorPolyhamide);
d7599219 3970}
bf210566 3971 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3972 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3973 90.,90,-90.);
3974 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3975 0.,90.,0.);
3976 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3977 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3978 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3979 + fgkSSDFlexWidth[0],0.,0.,
3980 new TGeoRotation((*laddercablesegmentarbrot[1])
3981 *(*laddercablesegmentarbrot[0])));
3982 TGeoVolume* laddercablesegmentarbassembly =
3983 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3984 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3985 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3986 laddercablesegmentarbcombitrans);
3987/////////////////////////////////////////
3988// End Ladder Cable Volume
3989/////////////////////////////////////////
3990 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3991 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3992 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3993 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3994 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3995 0.5*ssdendladdercablelength,
3996 0.5*fgkSSDLadderCableWidth,
3997 0.5*fgkSSDFlexHeight[i]);
3998 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3999 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
4000 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
4001 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
4002 ladderendcablesegmentbbox[i] =
4003 new TGeoVolume(ladderendcablesegmentbboxname[i],
4004 ladderendcablesegmentbboxshape[i],
4005 (i==0?fSSDAlTraceLadderCableMedium:
4006 fSSDKaptonLadderCableMedium));
4007 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
4008 fColorPolyhamide);
4009 }
4010 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
4011 ladderendcablesegmentbboxtrans[0] =
4012 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
4013 0.5*ssdendladdercablelength,
4014 0.5*fgkSSDLadderCableWidth,
4015 0.5*fgkSSDFlexHeight[0]);
4016 ladderendcablesegmentbboxtrans[1] =
4017 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
4018 0.5*ssdendladdercablelength,
4019 0.5*fgkSSDLadderCableWidth,
4020 fgkSSDFlexHeight[0]
4021 +0.5*fgkSSDFlexHeight[1]);
4022 TGeoVolume* ladderendcablesegmentbboxassembly =
4023 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
4024 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
4025 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
4026 ladderendcablesegmentbboxtrans[i]);
4027/////////////////////////////////////////
4028 TList* laddercablesegmentlist = new TList();
4029 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
4030 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
4031 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
4032 return laddercablesegmentlist;
4033 }
4034/////////////////////////////////////////////////////////////////////////////////
4035TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 4036 /////////////////////////////////////////////////////////////
bf210566 4037 // Method generating Ladder Cable Volumes Assemblies
44285dfa 4038 /////////////////////////////////////////////////////////////
bf210566 4039 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
4040 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
4041 for(Int_t i=0; i<n; i++){
4042 TGeoTranslation* laddercabletrans = new TGeoTranslation(
4043 i*(fgkCarbonFiberJunctionWidth),
4044 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4045 i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4046 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
4047 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
d7599219 4048 }
bf210566 4049 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
4050 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4051 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4052 (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4053 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
4054 return laddercable;
4055}
4056/////////////////////////////////////////////////////////////////////////////////
4057TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
4058 /////////////////////////////////////////////////////////////
4059 // Method generating Ladder Cable Volumes Assembly
4060 /////////////////////////////////////////////////////////////
4061 TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
4062 char laddercabletransname[30];
4063 for(Int_t i=0; i<n; i++){
4064 sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
4065 laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
4066 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
d7599219 4067 }
bf210566 4068 return laddercableassembly;
4069}
4070/////////////////////////////////////////////////////////////////////////////////
4071TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
4072 /////////////////////////////////////////////////////////////
4073 // Method generating Ladder Cable List Assemblies
4074 /////////////////////////////////////////////////////////////
4075 const Int_t kladdercableassemblynumber = 2;
4076 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
4077 TGeoVolume* ladderCable[kladdercableassemblynumber];
4078 char laddercableassemblyname[30];
4079 TList* laddercableassemblylist = new TList();
4080 for(Int_t i=0; i<kladdercableassemblynumber; i++){
4081 sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
4082 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
4083 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
4084 new TGeoCombiTrans((n-1)
4085 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4086 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
4087 0.,new TGeoRotation("",180,0.,0.)));
4088 laddercableassemblylist->Add(ladderCable[i]);
4089}
4090 return laddercableassemblylist;
4091}
4092///////////////////////////////////////////////////////////////////////////////
4093void AliITSv11GeometrySSD::SetLadderSegment(){
4094 /////////////////////////////////////////////////////////////
4095 // Method Generating Ladder Segment Array
4096 /////////////////////////////////////////////////////////////
4097 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
4098 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
4099 if(!fCreateMaterials) CreateMaterials();
4100 if(!fTransformationMatrices) CreateTransformationMatrices();
4101 if(!fBasicObjects) CreateBasicObjects();
4102 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
4103 // Placing Carbon Fiber Support
4104 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
4105 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4106 fcarbonfibersupportmatrix[j]);
4107 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4108 fcarbonfibersupportmatrix[j]);
d7599219 4109 }
bf210566 4110 // Placing Carbon Fiber Junction
4111 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
4112 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
4113 fcarbonfiberjunctionmatrix[j]);
4114 // Placing Carbon Fiber Lower Support
4115 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++)
4116 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
4117 fcarbonfiberlowersupportrans[j]);
4118 // Placing SSD Sensor Support
4119 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
4120 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
4121 fssdsensorsupport[1][i],
4122 j+1,fssdsensorsupportmatrix[j]);
4123 // Placing SSD Cooling Tube Support
4124 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
4125 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4126 fcoolingtubesupportmatrix[j]);
4127 // Placing SSD Cooling Tube
4128 for(Int_t j=0; j<2; j++)
4129 for(Int_t k=0; k<2; k++){
4130 fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]);
4131 fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]);
4132 }
4133 // Placing SSD Hybrid
4134 switch(i){
4135 case 0:
4136 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
4137 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4138 break;
4139 case 1:
4140 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
4141 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4142 break;
4143 }
4144 // Placing Cooling Block System
4145 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
4146 // Placing SSD Flex
4147 for(Int_t j=0; j<fgkflexnumber; j++){
4148 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
4149 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
4150 }
4151 }
d7599219 4152}
bf210566 4153///////////////////////////////////////////////////////////////////////////////
4154void AliITSv11GeometrySSD::SetEndLadderSegment(){
4155 /////////////////////////////////////////////////////////////
4156 // Method Generating End Ladder
4157 /////////////////////////////////////////////////////////////
4158 // End Ladder Carbon Fiber Junction
4159 /////////////////////////////////////////////////////////////
4160 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
4161 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
4162 if(!fCreateMaterials) CreateMaterials();
4163 if(!fTransformationMatrices) CreateTransformationMatrices();
4164 if(!fBasicObjects) CreateBasicObjects();
4165 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
4166 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
4167 fendladdersegment[i]->AddNode(j==2 ?
4168 fendladdercarbonfiberjunction[i][1] :
4169 fendladdercarbonfiberjunction[i][0],
4170 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
4171 }
4172 /////////////////////////////////////////////////////////////
4173 // End Ladder Carbon Fiber Support
4174 /////////////////////////////////////////////////////////////
4175 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
4176 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
4177 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4178 fendladdercarbonfibermatrix[i][j]);
4179 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4180 fendladdercarbonfibermatrix[i][j]);
4181 }
4182 /////////////////////////////////////////////////////////////
4183 // End Ladder Mounting Block
4184 /////////////////////////////////////////////////////////////
9b0c60ab 4185 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4186 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
e21cdd03 4187 fendladdermountingblockcombitrans[i]);
9b0c60ab 4188 /////////////////////////////////////////////////////////////
e5bf64ae 4189 // End Ladder Mounting Block Clip
9b0c60ab 4190 /////////////////////////////////////////////////////////////
4191 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4192 for(Int_t j=0; j<2; j++)
e21cdd03 4193 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
4194 fendladdermountingblockclipmatrix[i][j]);
bf210566 4195 /////////////////////////////////////////////////////////////
4196 // End Ladder Lower Supports
44285dfa 4197 /////////////////////////////////////////////////////////////
bf210566 4198 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
e21cdd03 4199 fendladderlowersupptrans[0]);
bf210566 4200 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
e21cdd03 4201 fendladderlowersupptrans[1]);
bf210566 4202 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
e21cdd03 4203 fendladderlowersupptrans[2]);
9b0c60ab 4204 /////////////////////////////////////////////////////////////
4205 // End Ladder Cooling Tube Support
4206 /////////////////////////////////////////////////////////////
4207 for(Int_t i=0; i<2; i++)
4208 for(Int_t j=0; j<(i==0?4:2); j++)
e21cdd03 4209 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4210 fendladdercoolingtubesupportmatrix[i][j]);
9b0c60ab 4211 /////////////////////////////////////////////////////////////
4212 // End Ladder Cooling Tube Support
4213 /////////////////////////////////////////////////////////////
4214 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
4215 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
4216 fendladdersegment[0]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[0][2]);
4217 fendladdersegment[0]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[0][3]);
4218 fendladdersegment[0]->AddNode(fendladdercoolingtube[2],1,fendladdercoolingtubematrix[0][4]);
4219 fendladdersegment[0]->AddNode(fendladdercoolingtube[2],2,fendladdercoolingtubematrix[0][5]);
4220 fendladdersegment[1]->AddNode(fendladdercoolingtube[3],1,fendladdercoolingtubematrix[1][0]);
4221 fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);
4222 fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);
4223 fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);
bf210566 4224}
4225///////////////////////////////////////////////////////////////////////////////
4226void AliITSv11GeometrySSD::SetLadder(){
4227 /////////////////////////////////////////////////////////////
4228 // Method Generating Ladder of Layer 5 and 6
44285dfa 4229 /////////////////////////////////////////////////////////////
bf210566 4230 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
4231 fgkSSDLay6SensorsNumber};
4232 /////////////////////////////////////////////////////////////////////////////
4233 /// Generating Ladder Mother Volume Containing Ladder
4234 /////////////////////////////////////////////////////////////////////////////
4235 TGeoXtru* laddershape[fgkladdernumber];
4236 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
4237 const Int_t kmothervertexnumber = 8;
4238 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
4239 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
4240 ///////////////////////
4241 // Setting the vertices
4242 ///////////////////////
4243 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
4244 * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
4245 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
e21cdd03 4246 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
4247 - fgkSSDModuleVerticalDisalignment;
bf210566 4248 xmothervertex[0][1] = xmothervertex[0][0];
4249 ymothervertex[0][1] = 0.0;
4250 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
4251 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
4252 ymothervertex[0][2] = ymothervertex[0][1];
4253 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
4254 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
4255 xmothervertex[0][4] = -xmothervertex[0][3];
4256 ymothervertex[0][4] = ymothervertex[0][3];
4257 xmothervertex[0][5] = -xmothervertex[0][2];
4258 ymothervertex[0][5] = ymothervertex[0][2];
4259 xmothervertex[0][6] = -xmothervertex[0][1];
4260 ymothervertex[0][6] = ymothervertex[0][1];
4261 xmothervertex[0][7] = -xmothervertex[0][0];
4262 ymothervertex[0][7] = ymothervertex[0][0];
4263 for(Int_t i=0; i<kmothervertexnumber; i++){
4264 xmothervertex[1][i] = xmothervertex[0][i];
4265 ymothervertex[1][i] = ymothervertex[0][i];
4266 }
4267 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4268 for(Int_t i=0; i<fgkladdernumber; i++){
4269 laddershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
4270 ymothervertex[i]);
4271 laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4272 laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4273 +fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4274 fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir);
9b0c60ab 4275 fladder[i]->SetLineColor(4);
bf210566 4276 }
4277///////////////////////////////////////////////////////////////////////////
4278 if(!fCreateMaterials) CreateMaterials();
4279 if(!fTransformationMatrices) CreateTransformationMatrices();
4280 if(!fBasicObjects) CreateBasicObjects();
4281 SetLadderSegment();
4282 SetEndLadderSegment();
4283 for(Int_t i=0; i<fgkladdernumber; i++){
4284 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4285 //////////////////////////
4286 /// Placing Ladder Segment
4287 //////////////////////////
4288 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4289 fladdersegment[i==0 ? 1 : 0],
4290 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4291 //////////////////////////
4292 /// Placing SSD Sensor
4293 //////////////////////////
4294 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4295 fssdsensormatrix[i][j]);
4296 }
4297 ///////////////////////////////
4298 /// Placing End Ladder Segment
4299 ///////////////////////////////
4300 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4301 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4302 }
d7599219 4303/////////////////////////////////////////////////////////////////////////////
4304/// Placing Ladder Cables
4305/////////////////////////////////////////////////////////////////////////////
bf210566 4306 Int_t sidecablenumber[2][2];
4307 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4308 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4309 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4310 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4311 Double_t carbonfibertomoduleposition[3];
4312 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4313 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4314 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4315 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4316 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4317 - fgkSSDSensorCenterSupportThickness[0]);
4318 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4319 + 0.5*fgkCoolingTubeSupportHeight
4320 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4321 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4322 Double_t ssdendladdercablelength[4];
4323 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4324 + fgkSSDSensorLength
4325 - fgkSSDModuleStiffenerPosition[1]
4326 - fgkSSDStiffenerWidth
4327 - fgkSSDFlexWidth[0]
bf210566 4328 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4329 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4330 + fgkSSDModuleStiffenerPosition[1]
4331 + fgkSSDStiffenerWidth
bf210566 4332 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4333 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4334 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4335 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4336 - kendladdercablecorrection;
44285dfa 4337 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4338 + carbonfibertomoduleposition[1]
d7599219 4339 - fgkSSDModuleStiffenerPosition[1]
4340 - fgkSSDStiffenerWidth)
bf210566 4341 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
44285dfa 4342 TList* laddercableassemblylist[4];
4343 const Int_t kendladdercablesnumber = 4;
bf210566 4344 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4345 for(Int_t j=0; j<kendladdercablesnumber; j++){
4346 laddercableassemblylist[j] =
4347 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4348 ssdendladdercablelength[j]);
4349 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4350 j<2?1:2,fladdercablematrix[i][j]);
4351 }
bf210566 4352}
4353////////////////////////////////////////////////////////////////////////////////
4354void AliITSv11GeometrySSD::SetLayer(){
d7599219 4355////////////////////////////////////////////////////////////////////////////////
bf210566 4356 // Creating Ladder of Layer 5 and Layer 6
4357 /////////////////////////////////////////////////////////////
4358 if(!fCreateMaterials) CreateMaterials();
4359 if(!fTransformationMatrices) CreateTransformationMatrices();
4360 if(!fBasicObjects) CreateBasicObjects();
4361 SetLadder(); // Generating the ladder of Layer5 and Layer6
4362 const Int_t kssdlayladdernumber[fgklayernumber] =
4363 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4364 /////////////////////////////////////////////////////////////
4365 // Generating mother volumes for Layer5 and Layer6
4366 /////////////////////////////////////////////////////////////
e5bf64ae 4367 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4368 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
bf210566 4369 Int_t *ladderindex[fgklayernumber];
4370 Int_t index[fgklayernumber] = {8,9};
4371 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4372 for(Int_t i=0; i<fgklayernumber; i++)
4373 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4374 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4375 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4376 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4377 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4378 }
44285dfa 4379 /////////////////////////////////////////////////////////////
bf210566 4380 // Deallocating memory
4381 /////////////////////////////////////////////////////////////
9b0c60ab 4382 for(Int_t i=0; i<fgklayernumber; i++) delete ladderindex[i];
d7599219 4383}
4384////////////////////////////////////////////////////////////////////////////////
4385void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4386 /////////////////////////////////////////////////////////////
4387 // Insert the layer 5 in the mother volume.
4388 /////////////////////////////////////////////////////////////
4389 if (! moth) {
4390 printf("Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!\n");
4391 return;
4392 };
bf210566 4393 if(!fSSDLayer5) SetLayer();
4394 fMotherVol = moth;
4395 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4396 + fgkLay5CenterITSPosition);
4397 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4398 }
d7599219 4399////////////////////////////////////////////////////////////////////////////////
4400void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4401 /////////////////////////////////////////////////////////////
4402 // Insert the layer 6 in the mother volume.
4403 /////////////////////////////////////////////////////////////
4404 if (! moth) {
4405 printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4406 return;
4407 };
bf210566 4408 if(!fSSDLayer6) SetLayer();
4409 fMotherVol = moth;
4410 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4411 + fgkLay6CenterITSPosition);
4412 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4413 }
bf210566 4414 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4415 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4416 /////////////////////////////////////////////////////////////
4417 // Method generating the Arc structure of Ladder Support
4418 /////////////////////////////////////////////////////////////
4419 const Int_t kssdlayladdernumber[fgklayernumber] =
4420 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4421 Double_t mountingsupportedge[fgklayernumber];
4422 Double_t mountingblockratio[fgklayernumber];
4423 Double_t theta[fgklayernumber];
4424 Double_t phi[fgklayernumber];
4425 Double_t psi0[fgklayernumber];
4426 Double_t deltapsi[fgklayernumber];
4427 TVector3* mountingsupportedgevector[fgklayernumber];
4428 for(Int_t i=0; i<fgklayernumber; i++){
4429 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4430 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4431 *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4432 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4433 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4434 / kssdlayladdernumber[i])));
4435 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4436 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4437 mountingsupportedgevector[i] = new TVector3();
4438 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4439 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(1.
4440 -TMath::Power(mountingsupportedgevector[i]->X()
4441 / fgkMountingBlockSupportRadius[i],2)));
4442 psi0[i] = 0.5*TMath::Pi()-phi[i];
4443 deltapsi[i] = (theta[i]+phi[i])/nedges;
4444 }
4445 TVector3** vertex[fgklayernumber];
4446 TList* vertexlist[fgklayernumber];
4447 Int_t indexedge[fgklayernumber] = {0,0};
4448 for(Int_t i=0; i<fgklayernumber; i++){
4449 vertex[i] = new TVector3*[nedges+1];
4450 vertexlist[i] = new TList();
4451 }
4452 for(Int_t i=0; i<fgklayernumber; i++){
4453 for(Int_t j=0; j<nedges+1; j++){
4454 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4455 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4456 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4457 vertexlist[i]->Add(vertex[i][j]);
4458 }
4459 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4460 }
4461 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4462 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4463 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4464 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4465 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4466 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4467 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4468 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4469 for(Int_t i=0; i<fgklayernumber; i++){
4470 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4471 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4472 xcentervertex[i] = new Double_t[indexedge[i]+3];
4473 ycentervertex[i] = new Double_t[indexedge[i]+3];
4474 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4475 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4476 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4477 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4478 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4479 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4480 ((TVector3*)vertexlist[i]->At(j))->X();
4481 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4482 ((TVector3*)vertexlist[i]->At(j))->Y();
4483 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4484 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4485 if(j<indexedge[i]+1){
4486 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4487 ((TVector3*)vertexlist[i]->At(j))->X();
4488 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4489 ((TVector3*)vertexlist[i]->At(j))->Y();
4490 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4491 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4492 }
4493 }
4494 xsidevertex[i][1] = xsidevertex[i][0];
4495 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4496 xsidevertex[i][2] = xsidevertex[i][3];
4497 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4498 xcentervertex[i][1] = xcentervertex[i][0];
4499 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4500 xcentervertex[i][2] = xcentervertex[i][3];
4501 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4502 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4503 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4504 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4505 ycenterlowervertex[i][0] = ysidevertex[i][0];
4506 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4507 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4508 }
4509 /////////////////////////////////////////////////////////////
4510 // Building the Arc Structure of Ladder Supports
4511 /////////////////////////////////////////////////////////////
4512 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4513 TGeoXtru* centermountingsupportshape[fgklayernumber];
4514 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4515 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4516 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4517 TGeoVolume* centermountingblocksupport[fgklayernumber];
4518 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4519 TGeoVolume* centerladdersupportpiece[fgklayernumber];
4520 char sidemountingblockname[40];
4521 char centermountingblockname[40];
4522 char sideladdersupportpiecename[40];
4523 char centerladdersupportpiecename[40];
4524 for(Int_t i=0; i<fgklayernumber; i++){
4525 sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4526 sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4527 sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4528 sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4529 sidemountingblocksupportshape[i] = new TGeoXtru(2);
4530 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4531 xsidevertex[i],ysidevertex[i]);
4532 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4533 -fgkMountingBlockSupportWidth[0]);
4534 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4535 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4536 sidemountingblocksupportshape[i],
4537 fSSDAlCoolBlockMedium);
4538 sidemountingblocksupport[i]->SetLineColor(9);
4539 centermountingsupportshape[i] = new TGeoXtru(2);
4540 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4541 xcentervertex[i],ycentervertex[i]);
4542 centermountingsupportshape[i]->DefineSection(0,0.);
4543 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4544 -fgkMountingBlockSupportWidth[0]);
4545 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4546 centermountingsupportshape[i],
4547 fSSDAlCoolBlockMedium);
4548 centermountingblocksupport[i]->SetLineColor(9);
4549 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4550 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4551 xsidelowervertex[i],ysidelowervertex[i]);
4552 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4553 -fgkMountingBlockSupportWidth[0]);
4554 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4555 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4556 sideladdersupportpieceshape[i],
e21cdd03 4557 fSSDCarbonFiberMedium);
9b0c60ab 4558 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4559 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4560 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4561 xcenterlowervertex[i],ycenterlowervertex[i]);
4562 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4563 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4564 -fgkMountingBlockSupportWidth[0]);
4565 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4566 centerladdersupportpieceshape[i],
e21cdd03 4567 fSSDCarbonFiberMedium);
9b0c60ab 4568 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4569 }
4570 /////////////////////////////////////////////////////////////
4571 // Building the Up Structure of Ladder Supports
4572 /////////////////////////////////////////////////////////////
4573 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4574 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4575 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4576 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4577 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4578 //////////////////////////////////////////////////////////
4579 // Setting the volume for TGeoXtru Mounting Block Piece
4580 //////////////////////////////////////////////////////////
4581 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4582 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4583 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4584 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4585 TGeoVolume* mountingblockpieceup[fgklayernumber];
4586 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4587 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4588 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4589 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
4590 char mountingblockpiecedownname[34];
4591 char mountingblockpieceupname[34];
4592 for(Int_t i=0; i<fgklayernumber; i++){
4593 ///////////////////////////
4594 // Mounting Block Down Vertex
4595 ///////////////////////////
4596 mountingblockpiecedownshape[i] = new TGeoXtru(2);
4597 sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4598 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4599 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4600 + fgkMountingBlockSupportDownHeight;
4601 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4602 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4603 + fgkSSDMountingBlockHeight[1]
4604 - 0.5*fgkCoolingTubeSupportHeight
e21cdd03 4605 - fgkSSDModuleCoolingBlockToSensor
4606 - fgkSSDModuleVerticalDisalignment;
9b0c60ab 4607 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4608 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4609 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4610 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4611 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4612 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4613 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4614 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4615 + fgkSSDMountingBlockHeight[2]
4616 - fgkSSDMountingBlockHeight[0];
4617 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4618 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4619 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4620 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4621 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4622 mountingblockpiecedownyvertex[i]);
4623 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4624 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4625 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
e21cdd03 4626 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
9b0c60ab 4627 mountingblockpiecedown[i]->SetLineColor(fColorG10);
4628 ///////////////////////////
4629 // Mounting Block Up Vertex
4630 ///////////////////////////
4631 mountingblockpieceupshape[i] = new TGeoXtru(2);
4632 sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4633 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4634 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4635 + fgkMountingBlockSupportUpHeight[i];
4636 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4637 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4638 + fgkSSDMountingBlockHeight[1]
4639 - 0.5*fgkCoolingTubeSupportHeight
e21cdd03 4640 - fgkSSDModuleCoolingBlockToSensor
4641 - fgkSSDModuleVerticalDisalignment;
9b0c60ab 4642 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4643 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4644 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4645 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4646 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4647 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4648 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4649 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4650 + fgkSSDMountingBlockHeight[2]
4651 - fgkSSDMountingBlockHeight[0];
4652 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4653 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4654 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4655 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4656 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4657 mountingblockpieceupyvertex[i]);
4658 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4659 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4660 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
e21cdd03 4661 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
9b0c60ab 4662 mountingblockpieceup[i]->SetLineColor(fColorG10);
4663 }
4664 ///////////////////////////////////////////////////////////////////
4665 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4666 ///////////////////////////////////////////////////////////////////
4667 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4668 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4669 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4670 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4671 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4672 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4673 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4674 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4675 char mountingblocksupportrapezoidowname[40];
4676 char mountingblocksupportrapezoidupname[40];
4677 Double_t scalefactor = 3./4.;
4678 for(Int_t i=0; i<fgklayernumber; i++){
4679 ////////////////////////////////////////////
4680 // Mounting Block Support Down Trapezoid Vertex
4681 ////////////////////////////////////////////
4682 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4683 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4684 - mountingsupportedge[i];
4685 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4686 mountingblocksupportrapezoidownxvertex[i][1] =
4687 mountingblocksupportrapezoidownxvertex[i][0];
4688 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4689 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4690 - mountingblockpiecedownyvertex[i][0]);
4691 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4692 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4693 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4694 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4695 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4696 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4697 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4698 mountingblocksupportrapezoidownyvertex[i]);
4699 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4700 -fgkMountingBlockSupportWidth[0]);
4701 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4702 sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4703 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
e21cdd03 4704 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4705 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4706 ////////////////////////////////////////////
4707 // Mounting Block Support Up Trapezoid Vertex
4708 ////////////////////////////////////////////
4709 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4710 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4711 - mountingsupportedge[i];
4712 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4713 mountingblocksupportrapezoidupxvertex[i][1] =
4714 mountingblocksupportrapezoidupxvertex[i][0];
4715 mountingblocksupportrapezoidupyvertex[i][1] =
4716 mountingblockpieceupyvertex[i][0]
4717 + scalefactor*(mountingblockpieceupyvertex[i][1]
4718 - mountingblockpieceupyvertex[i][0]);
4719 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4720 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4721 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4722 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4723 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4724 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4725 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4726 mountingblocksupportrapezoidupyvertex[i]);
4727 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4728 -fgkMountingBlockSupportWidth[0]);
4729 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4730 sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4731 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
e21cdd03 4732 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4733 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4734 }
4735 ///////////////////////////////////////////////////////////////////
4736 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4737 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4738 Double_t boxoriginup[fgklayernumber][2][3];
4739 Double_t boxorigindown[fgklayernumber][2][3];
4740 char mountingblocksupportboxdownname[34];
4741 char mountingblocksupportboxupname[34];
4742 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4743 mountingblocksupportrot->SetAngles(90.,180.,-90);
4744 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4745 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4746 TGeoHMatrix* laddersupportmatrix[2];
4747 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4748 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4749 /////////////////////////////////////////////////////////////
4750 // Creating Mother Volume for Containment
4751 /////////////////////////////////////////////////////////////
4752 Double_t *xmothervertex[fgklayernumber];
4753 Double_t *ymothervertex[fgklayernumber];
4754 for(Int_t i=0; i<fgklayernumber; i++){
4755 xmothervertex[i] = new Double_t[8];
4756 ymothervertex[i] = new Double_t[8];
4757 }
4758 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4759 TGeoVolume* downmotherladdersupport[fgklayernumber];
4760 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4761 TGeoVolume* upmotherladdersupport[fgklayernumber];
4762 char upmotheladdersupportname[30];
4763 char downmotheladdersupportname[30];
4764 for(Int_t i=0; i<fgklayernumber; i++){
4765 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4766 - mountingsupportedge[i];
4767 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4768 xmothervertex[i][1] = xmothervertex[i][0];
4769 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4770 + fgkMountingBlockSupportWidth[0];
4771 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4772 ymothervertex[i][2] = ymothervertex[i][1];
4773 xmothervertex[i][3] = xmothervertex[i][2];
4774 ymothervertex[i][3] = -ymothervertex[i][0];
4775 xmothervertex[i][4] = -xmothervertex[i][0];
4776 ymothervertex[i][4] = ymothervertex[i][3];
4777 xmothervertex[i][5] = xmothervertex[i][4];
4778 ymothervertex[i][5] = -ymothervertex[i][1];
4779 xmothervertex[i][6] = -xmothervertex[i][2];
4780 ymothervertex[i][6] = ymothervertex[i][5];
4781 xmothervertex[i][7] = xmothervertex[i][6];
4782 ymothervertex[i][7] = ymothervertex[i][0];
4783 sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4784 sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
4785 downmotherladdersupportshape[i] = new TGeoXtru(2);
4786 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4787 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4788 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4789 + fgkMountingBlockSupportDownHeight
4790 + fgkSSDMountingBlockHeight[1]
4791 - 0.5*fgkCoolingTubeSupportHeight
e21cdd03 4792 - fgkSSDModuleCoolingBlockToSensor
4793 - fgkSSDModuleVerticalDisalignment);
9b0c60ab 4794 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4795 downmotherladdersupportshape[i],fSSDAir);
4796 upmotherladdersupportshape[i] = new TGeoXtru(2);
4797 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4798 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4799 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4800 + fgkMountingBlockSupportUpHeight[i]
4801 + fgkSSDMountingBlockHeight[1]
4802 - 0.5*fgkCoolingTubeSupportHeight
e21cdd03 4803 - fgkSSDModuleCoolingBlockToSensor
4804 - fgkSSDModuleVerticalDisalignment);
9b0c60ab 4805 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4806 upmotherladdersupportshape[i],fSSDAir);
4807 }
4808 for(Int_t i=0; i<fgklayernumber; i++){
4809 /////////////////////////
4810 // Setting the box origin
4811 /////////////////////////
4812 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4813 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
4814 + 0.5*fgkMountingBlockSupportDownHeight;
4815 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4816 - 0.5*fgkMountingBlockSupportWidth[0];
4817
4818 boxorigindown[i][1][0] = 0.0;
4819 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4820 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4821 - fgkMountingBlockSupportWidth[0]);
4822
4823 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4824 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4825 + 0.5*fgkMountingBlockSupportUpHeight[i];
4826 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4827 - 0.5*fgkMountingBlockSupportWidth[0];
4828
4829 boxoriginup[i][1][0] = 0.0;
4830 boxoriginup[i][1][1] = fgkMountingBlockSupportRadius[i]
4831 + 0.5*fgkMountingBlockSupportUpHeight[i];
4832 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4833 - fgkMountingBlockSupportWidth[0]);
4834
4835 /////////////////////////
4836 // Setting the boxes
4837 /////////////////////////
4838 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4839 + fgkSSDMountingBlockLength[0]),
4840 0.5*fgkMountingBlockSupportDownHeight,
4841 0.5*fgkMountingBlockSupportWidth[0],
4842 boxorigindown[i][0]);
4843 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4844 0.5*fgkMountingBlockSupportDownHeight,
4845 0.5*(fgkMountingBlockSupportWidth[1]
4846 - fgkMountingBlockSupportWidth[0]),
4847 boxorigindown[i][1]);
4848
4849 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4850 + fgkSSDMountingBlockLength[0]),
4851 0.5*fgkMountingBlockSupportUpHeight[i],
4852 0.5*fgkMountingBlockSupportWidth[0],
4853 boxoriginup[i][0]);
4854
4855 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4856 0.5*fgkMountingBlockSupportUpHeight[i],
4857 0.5*(fgkMountingBlockSupportWidth[1]
4858 - fgkMountingBlockSupportWidth[0]),
4859 boxoriginup[i][1]);
4860 ///////////////////////////////////////
4861 // Adding the Volumes to Mother Volume
4862 ///////////////////////////////////////
4863 for(Int_t j=0; j<2; j++){
4864 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4865 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4866 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4867 mountingblocksupportboxdownshape[i][j],
e21cdd03 4868 fSSDCarbonFiberMedium);
9b0c60ab 4869 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4870 mountingblocksupportboxupshape[i][j],
e21cdd03 4871 fSSDCarbonFiberMedium);
9b0c60ab 4872 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4873 mountingblocksupportboxup[i][j]->SetLineColor(9);
4874 for(Int_t k=0; k<2; k++){
4875 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4876 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4877 }
4878 }
4879 for(Int_t k=0; k<2; k++){
4880 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4881 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4882 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4883 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4884 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4885 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4886 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4887 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4888 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4889 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4890 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4891 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
4892 }
4893 }
4894 TList* laddersupportlist = new TList();
4895 laddersupportlist->Add(downmotherladdersupport[0]);
4896 laddersupportlist->Add(upmotherladdersupport[0]);
4897 laddersupportlist->Add(downmotherladdersupport[1]);
4898 laddersupportlist->Add(upmotherladdersupport[1]);
4899 /////////////////////////////////////////////////////////////
4900 // Deallocating memory
4901 /////////////////////////////////////////////////////////////
4902 for(Int_t i=0; i<fgklayernumber; i++){
4903 for(Int_t j=0; j<nedges+1; j++)
4904 delete vertex[i][j];
4905 delete mountingsupportedgevector[i];
4906 delete [] vertex[i];
4907 delete vertexlist[i];
4908 delete [] xsidevertex[i];
4909 delete [] ysidevertex[i];
4910 delete [] xcentervertex[i];
4911 delete [] ycentervertex[i];
4912 delete [] xsidelowervertex[i];
4913 delete [] ysidelowervertex[i];
4914 delete [] xcenterlowervertex[i];
4915 delete [] ycenterlowervertex[i];
4916 }
4917 delete xsidevertex;
4918 delete ysidevertex;
4919 delete xcentervertex;
4920 delete ycentervertex;
4921 delete xsidelowervertex;
4922 delete ysidelowervertex;
4923 delete xcenterlowervertex;
4924 delete ycenterlowervertex;
4925 delete globalrefladdersupportrot;
4926 delete mountingblocksupportrot;
4927 /////////////////////
4928 return laddersupportlist;
4929}
4930 ////////////////////////////////////////////////////////////////////////////////
4931void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4932//////////////////////////////////////////
4933// Method Generating Ladder Support Ring
4934//////////////////////////////////////////
4935 if(!fCreateMaterials) CreateMaterials();
4936 if(!fTransformationMatrices) CreateTransformationMatrices();
4937 if(!fBasicObjects) CreateBasicObjects();
4938 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4939 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4940 const Int_t kssdlayladdernumber[fgklayernumber] =
4941 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4942 Double_t mountingsupportedge[fgklayernumber];
4943 Double_t mountingblockratio[fgklayernumber];
4944 Double_t theta[fgklayernumber];
4945 Double_t phi[fgklayernumber];
4946 for(Int_t i=0; i<fgklayernumber; i++){
4947 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4948 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4949 *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4950 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4951 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4952 / kssdlayladdernumber[i])));
4953 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4954 / fgkMountingBlockSupportRadius[i]);
4955 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4956 }
4957 TGeoRotation* globalrot = new TGeoRotation();
4958 globalrot->SetAngles(0.,-90.,0.);
4959 TGeoRotation** laddersupportrot[fgklayernumber];
4960 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4961 for(Int_t i=0; i<fgklayernumber; i++){
4962 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4963 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4964 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4965 laddersupportrot[i][j] = new TGeoRotation();
4966 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4967 switch(i){
4968 case 0: //Ladder of Layer5
4969 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4970 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4971 laddersupportmatrix[i][j]);
4972 break;
4973 case 1: //Ladder of Layer6
4974 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4975 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4976 laddersupportmatrix[i][j]);
4977 break;
4978 }
4979 }
4980 }
4981 /////////////////////////////////////////////////////////////
4982 // Creating Lower Ladder Support
4983 /////////////////////////////////////////////////////////////
4984 TVector3** ringsupportvertex[fgklayernumber];
4985 Double_t angle = 360./nedges;
4986 for(Int_t i=0; i<fgklayernumber; i++){
4987 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4988 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4989 * TMath::Cos(theta[i]));
4990 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4991 - mountingsupportedge[i],
4992 ringsupportvertex[i][0]->Y());
4993 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4994 ringsupportvertex[i][1]->Y());
4995 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4996 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4997 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4998 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4999 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
5000 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
5001 }
5002 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
5003 for(Int_t j=0; j<nedges+1; j++){
5004 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
5005 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*CosD(90.0-j*angle),
5006 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*SinD(90.0-j*angle));
5007 }
5008 }
5009 Double_t **xmothervertex = new Double_t*[fgklayernumber];
5010 Double_t **ymothervertex = new Double_t*[fgklayernumber];
5011 for(Int_t i=0; i<fgklayernumber; i++){
5012 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5013 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5014 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
5015 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
5016 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
5017 }
5018 }
5019 char lowerladdersupportname[30];
5020 TGeoXtru* lowerladdersupportshape[fgklayernumber];
5021 TGeoVolume* lowerladdersupport[fgklayernumber];
5022 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5023 lowerladdersupportrot->SetAngles(90.,180.,-90);
5024 for(Int_t i=0; i<fgklayernumber; i++){
5025 lowerladdersupportshape[i] = new TGeoXtru(2);
5026 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
5027 xmothervertex[i],ymothervertex[i]);
5028 lowerladdersupportshape[i]->DefineSection(0,0.);
5029 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
5030 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
5031 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
5032 lowerladdersupportshape[i],fSSDSupportRingAl);
5033 lowerladdersupport[i]->SetLineColor(fColorAl);
5034 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
5035 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
5036 }
5037 /////////////////////////////////////////////////////////////
5038 // Deallocating memory
5039 /////////////////////////////////////////////////////////////
5040 for(Int_t i=0; i<fgklayernumber; i++){
5041 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
5042 delete ringsupportvertex[i][j];
5043 delete [] ringsupportvertex[i];
5044 }
5045 for(Int_t i=0; i<fgklayernumber; i++){
5046 delete [] xmothervertex[i];
5047 delete [] ymothervertex[i];
5048 }
5049 delete xmothervertex;
5050 delete ymothervertex;
5051 delete globalrot;
5052 for(Int_t i=0; i<fgklayernumber; i++){
5053 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
5054 delete laddersupportrot[i][j];
5055 delete [] laddersupportrot[i];
5056 }
5057 }
5058 ////////////////////////////////////////////////////////////////////////////////
5059 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
5060 /////////////////////////////////////////////////////////////
5061 // Method generating Endcap CoverPlate
5062 /////////////////////////////////////////////////////////////
5063 // Holes Definition
5064 ///////////////////
5065 Int_t nendcapcoverplateholedges = 30;
5066 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
5067 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
5068 0.5*fgkEndCapCoverPlateThickness};
5069 TGeoXtru* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
5070 nendcapcoverplateholedges,holesection);
5071 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 5072 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 5073 endcapcoverplatesmallhole->SetLineColor(6);
5074 TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
5075 nendcapcoverplateholedges,holesection);
5076 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 5077 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 5078 endcapcoverplatebighole->SetLineColor(6);
5079 //////////////////////////
5080 // Screw Piece Definition
5081 //////////////////////////
5082 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
5083 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
5084 CosD(0.5*smallscrewangle),
5085 0.5*fgkEndCapCoverPlateThickness);
5086 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
5087 endcapsmallscrewpieceshape,
5088 fSSDCoolingTubePhynox);
5089 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
5090 ///////////////////
5091 // Box Definition
5092 ///////////////////
5093 TGeoBBox* endcapcoverplateboxshape[4];
5094 TGeoVolume* endcapcoverplatebox[4];
5095 Double_t boxorigin[5][3];
5096 boxorigin[0][0] = 0.;
5097 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
5098 boxorigin[0][2] = 0.;
5099
5100 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
5101 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
5102 boxorigin[1][2] = 0.;
5103
5104 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
5105 + fgkEndCapCoverPlateSmallHoleSeparation[1];
5106 boxorigin[2][1] = boxorigin[1][1];
5107 boxorigin[2][2] = 0.;
5108
5109 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
5110 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
5111 boxorigin[3][1] = boxorigin[1][1];
5112 boxorigin[3][2] = 0.;
5113
5114 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5115 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5116 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
5117 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5118
5119 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5120 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5121 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5122 + fgkEndCapCoverPlateSmallHoleRadius,
5123 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5124
5125 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5126 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5127 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5128 + fgkEndCapCoverPlateSmallHoleRadius,
5129 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5130
5131 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5132 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5133 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5134 + fgkEndCapCoverPlateSmallHoleRadius,
5135 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5136
5137 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 5138 fSSDAlCoolBlockMedium);
9b0c60ab 5139 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 5140 fSSDAlCoolBlockMedium);
9b0c60ab 5141 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 5142 fSSDAlCoolBlockMedium);
9b0c60ab 5143 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 5144 fSSDAlCoolBlockMedium);
9b0c60ab 5145 endcapcoverplatebox[0]->SetLineColor(6);
5146 endcapcoverplatebox[1]->SetLineColor(6);
5147 endcapcoverplatebox[2]->SetLineColor(6);
5148 endcapcoverplatebox[3]->SetLineColor(6);
5149 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5150 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5151 fgkEndCapCoverPlateSmallHoleRadius,
5152 0.5*fgkEndCapCoverPlateThickness,
5153 endcapfillingboxorigin);
5154 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 5155 fSSDAlCoolBlockMedium);
9b0c60ab 5156 endcapfillingbox->SetLineColor(6);
5157 ////////////////////////////
5158 // Contour Xtru Definition
5159 ////////////////////////////
5160 const Int_t kcontourvertexnumber = 10;
5161 Double_t xcontourvertex[kcontourvertexnumber];
5162 Double_t ycontourvertex[kcontourvertexnumber];
5163 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5164 xcontourvertex[1] = xcontourvertex[0];
5165 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5166 xcontourvertex[3] = xcontourvertex[2];
5167 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5168 xcontourvertex[5] = xcontourvertex[4];
5169 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5170 xcontourvertex[7] = xcontourvertex[6];
5171 xcontourvertex[8] = xcontourvertex[4];
5172 xcontourvertex[9] = xcontourvertex[8];
5173 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5174 - (kendcapcoverplatesmallholenumber[1]-1)
5175 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5176 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5177 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5178 ycontourvertex[2] = ycontourvertex[1];
5179 ycontourvertex[3] = ycontourvertex[0];
5180 ycontourvertex[4] = ycontourvertex[3];
5181 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5182 ycontourvertex[6] = ycontourvertex[5];
5183 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5184 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5185 + fgkEndCapCoverPlateSmallHoleRadius;
5186 ycontourvertex[8] = ycontourvertex[7];
5187 ycontourvertex[9] = ycontourvertex[0];
5188 TGeoXtru* contourshape = new TGeoXtru(2);
5189 contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex);
5190 contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5191 contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
e21cdd03 5192 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5193 fSSDAlCoolBlockMedium);
9b0c60ab 5194 contour->SetLineColor(6);
5195 /////////////////////////////
5196 // Hole Contour Xtru Definition
5197 ////////////////////////////
5198 const Int_t kholecontourvertexnumber = 10;
5199 Double_t xholecontourvertex[2][kcontourvertexnumber];
5200 Double_t yholecontourvertex[2][kcontourvertexnumber];
5201 xholecontourvertex[0][0] = xcontourvertex[0];
5202 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5203 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5204 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5205 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5206 + 0.5*(fgkEndCapCoverPlateLength[2]
5207 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5208 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5209 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5210 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5211 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5212 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5213 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5214
5215 yholecontourvertex[0][0] = ycontourvertex[1];
5216 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5217 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5218 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5219 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5220 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5221 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5222 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5223 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5224 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5225 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5226
5227 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5228 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5229 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5230 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5231 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5232 + 0.5*(fgkEndCapCoverPlateLength[2]
5233 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5234 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5235 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5236 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5237 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5238 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5239 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5240
5241 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5242 - fgkEndCapCoverPlateWidth[0]);
5243 yholecontourvertex[1][1] = ycontourvertex[0];
5244 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5245 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5246 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5247 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5248 - fgkEndCapCoverPlateWidth[0]
5249 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5250 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5251 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5252 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5253 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5254
5255 TGeoXtru* holecontourshape[2];
5256 holecontourshape[0] = new TGeoXtru(2);
5257 holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0],
5258 yholecontourvertex[0]);
5259 holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5260 holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5261
5262 holecontourshape[1] = new TGeoXtru(2);
5263 holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1],
5264 yholecontourvertex[1]);
5265 holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5266 holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5267
5268 TGeoVolume* holecontour[2];
e21cdd03 5269 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0],
5270 fSSDAlCoolBlockMedium);
9b0c60ab 5271 holecontour[0]->SetLineColor(6);
e21cdd03 5272 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1],
5273 fSSDAlCoolBlockMedium);
9b0c60ab 5274 holecontour[1]->SetLineColor(6);
5275 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5276 + fgkEndCapCoverPlateLength[2],0.,0.);
5277 TGeoTranslation* bigholetrans[3];
5278 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5279 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5280 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5281 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5282 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5283 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5284 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5285 /////////////////////////////////
5286 // Mother Volume Xtru Definition
5287 /////////////////////////////////
5288 const Int_t kmothervertexnumber = 12;
5289 Double_t xmothervertex[kmothervertexnumber];
5290 Double_t ymothervertex[kmothervertexnumber];
5291 xmothervertex[0] = xcontourvertex[0];
5292 xmothervertex[1] = xmothervertex[0];
5293 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5294 xmothervertex[3] = xmothervertex[2];
5295 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5296 xmothervertex[5] = xmothervertex[4];
5297 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5298 xmothervertex[7] = xmothervertex[6];
5299 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5300 + fgkEndCapCoverPlateLength[2];
5301 xmothervertex[9] = xmothervertex[8];
5302 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5303 xmothervertex[11] = xmothervertex[10];
5304
5305 ymothervertex[0] = ycontourvertex[0];
5306 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5307 ymothervertex[2] = ymothervertex[1];
5308 ymothervertex[3] = ycontourvertex[1];
5309 ymothervertex[4] = ymothervertex[3];
5310 ymothervertex[5] = ymothervertex[1];
5311 ymothervertex[6] = ymothervertex[5];
5312 ymothervertex[7] = ymothervertex[0];
5313 ymothervertex[8] = ymothervertex[7];
5314 ymothervertex[9] = ymothervertex[8]
5315 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5316 ymothervertex[10] = ymothervertex[9];
5317 ymothervertex[11] = ymothervertex[8];
5318 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5319 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5320 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5321 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5322 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5323 ////////////////////////////////////////
5324 // Adding Nodes
5325 ////////////////////////////////////////
5326// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5327 TGeoTranslation*** endcapcoverplatesmallholetrans;
5328 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5329 Double_t transx[4] = {0,
5330 fgkEndCapCoverPlateSmallHoleSeparation[0],
5331 fgkEndCapCoverPlateSmallHoleSeparation[0]
5332 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5333 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5334 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5335 Int_t index = 0;
5336 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5337 endcapcoverplatesmallholetrans[i] =
5338 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5339 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5340 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5341 endcapcoverplatesmallholetrans[i][j] =
5342 new TGeoTranslation(transx[i],
5343 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5344 if(index!=10){
5345 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5346 index,endcapcoverplatesmallholetrans[i][j]);
5347 mothercoverplate->AddNode(endcapsmallscrewpiece,
5348 index,endcapcoverplatesmallholetrans[i][j]);
5349 }
5350 if(j<kendcapcoverplatesmallholenumber[1]-1)
5351 mothercoverplate->AddNode(endcapcoverplatebox[0],
5352 index,endcapcoverplatesmallholetrans[i][j]);
5353 }
5354 }
5355 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5356 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5357 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5358 mothercoverplate->AddNode(endcapfillingbox,1);
5359 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5360 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5361 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5362 mothercoverplate->AddNode(holecontour[0],1);
5363 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5364 mothercoverplate->AddNode(holecontour[1],1);
5365 mothercoverplate->AddNode(contour,1);
5366 /////////////////////////////////
5367 return mothercoverplate;
5368 }
5369 ////////////////////////////////////////////////////////////////////////////////
5370 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5371 /////////////////////////////////////////////////////////////
5372 // Getting EndCap Cooling Tube
5373 /////////////////////////////////////////////////////////////
5374 TGeoTorus* endcapcoolingtubetorushape[5];
5375 TGeoVolume* endcapcoolingtubetorus[5];
5376 TGeoTube* endcapcoolingtubeshape[4];
5377 TGeoVolume* endcapcoolingtube[4];
5378 char endcapcoolingtubetorusname[30];
5379 char endcapcoolingtubename[30];
5380 TGeoTorus* endcapcoolingwatertubetorushape[5];
5381 TGeoVolume* endcapcoolingwatertubetorus[5];
5382 TGeoTube* endcapcoolingwatertubeshape[4];
5383 TGeoVolume* endcapcoolingwatertube[4];
5384 char endcapcoolingwatertubetorusname[30];
5385 char endcapcoolingwatertubename[30];
5386 for(Int_t i=0; i<5; i++){
5387 sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5388 sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5389 sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5390 sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5391 if(i==3){
5392 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5393 fgkEndCapCoolingTubeRadiusMin,
5394 fgkEndCapCoolingTubeRadiusMax,
5395 90.0,fgkEndCapCoolingTubeAngle[3]);
5396 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5397 0.,fgkEndCapCoolingTubeRadiusMin,
5398 90.0,fgkEndCapCoolingTubeAngle[3]);
5399 }
5400 else{
5401 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5402 :fgkEndCapCoolingTubeAxialRadius[1],
5403 fgkEndCapCoolingTubeRadiusMin,
5404 fgkEndCapCoolingTubeRadiusMax,
5405 0.,fgkEndCapCoolingTubeAngle[i]);
5406 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5407 :fgkEndCapCoolingTubeAxialRadius[1],
5408 0.,fgkEndCapCoolingTubeRadiusMin,
5409 0.,fgkEndCapCoolingTubeAngle[i]);
5410 }
5411 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5412 endcapcoolingtubetorushape[i],
5413 fSSDCoolingTubePhynox);
5414 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5415 endcapcoolingwatertubetorushape[i],
5416 fSSDCoolingTubeWater);
5417 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5418 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5419 if(i<4){
5420 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5421 fgkEndCapCoolingTubeRadiusMax,
5422 0.5*fgkEndCapCoolingTubeLength[i]);
5423 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5424 0.5*fgkEndCapCoolingTubeLength[i]);
5425 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5426 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5427 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5428 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5429 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5430 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5431 }
5432 }
5433 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5434 /////////////////////////////////////////
5435 // Transformation for Volume Positioning
5436 /////////////////////////////////////////
5437 TGeoCombiTrans* coolingtubecombitrans[6];
5438 TGeoRotation* coolingtuberot[8];
5439 TGeoTranslation* coolingtubetrans[6];
5440 TGeoHMatrix* coolingtubematrix[4];
5441 TGeoCombiTrans* torustubecombitrans[4];
5442 TGeoRotation* torustuberot[7];
5443 TGeoTranslation* torustubetrans[4];
5444 TGeoHMatrix* torustubematrix[5];
5445 TGeoCombiTrans* coolingwatertubecombitrans[6];
5446 TGeoRotation* coolingwatertuberot[8];
5447 TGeoTranslation* coolingwatertubetrans[6];
5448 TGeoHMatrix* coolingwatertubematrix[4];
5449 TGeoCombiTrans* toruswatertubecombitrans[4];
5450 TGeoRotation* toruswatertuberot[7];
5451 TGeoTranslation* toruswatertubetrans[4];
5452 TGeoHMatrix* toruswatertubematrix[5];
5453 for(Int_t i=0; i<8; i++){
5454 if(i<6){
5455 coolingtubetrans[i] = new TGeoTranslation();
5456 coolingwatertubetrans[i] = new TGeoTranslation();
5457 }
5458 if(i<8){
5459 coolingtuberot[i] = new TGeoRotation();
5460 coolingwatertuberot[i] = new TGeoRotation();
5461 }
5462 if(i<4){
5463 torustubetrans[i] = new TGeoTranslation();
5464 toruswatertubetrans[i] = new TGeoTranslation();
5465 }
5466 if(i<7){
5467 torustuberot[i] = new TGeoRotation();
5468 toruswatertuberot[i] = new TGeoRotation();
5469 }
5470 }
5471 /////////////////////////////////////////
5472 // Transformation for Inox Volume Positioning
5473 /////////////////////////////////////////
5474 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5475 -endcapcoolingtubeshape[0]->GetDz(),0.);
5476 coolingtuberot[0]->SetAngles(0.,90.,0.);
5477 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5478 *coolingtuberot[0]);
5479
5480 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5481 coolingtuberot[1]->SetAngles(0.,90.,0.);
5482 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5483 *coolingtuberot[1]);
5484
5485 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5486 *CosD(fgkEndCapCoolingTubeAngle[0]),
5487 fgkEndCapCoolingTubeAxialRadius[0]
5488 *SinD(fgkEndCapCoolingTubeAngle[0]),
5489 0.);
5490 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5491 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5492 *coolingtuberot[2]);
5493
5494 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5495 * (*coolingtubecombitrans[1]));
5496
5497 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5498 endcapcoolingtubeshape[1]->GetDz());
5499 torustuberot[0]->SetAngles(0.,90.,0.);
5500 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5501
5502 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5503
5504 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5505 -endcapcoolingtubeshape[2]->GetDz(),0.);
5506 coolingtuberot[3]->SetAngles(0.,90.,0.);
5507 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5508 *coolingtuberot[3]);
5509 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5510 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5511 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5512
5513 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5514 endcapcoolingtubeshape[2]->GetDz());
5515 torustuberot[1]->SetAngles(0.,90.,0.);
5516 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5517 torustuberot[2]->SetAngles(180.,0.,0.);
5518 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5519 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5520
5521 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5522 -fgkEndCapCoolingTubeAxialRadius[0]);
5523 torustuberot[3]->SetAngles(0.,90.,0.);
5524 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5525 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5526 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5527 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5528
5529 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5530 fgkEndCapCoolingTubeAxialRadius[0],0.);
5531 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5532 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5533 *coolingtuberot[5]);
5534 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5535 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5536 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5537
5538 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5539 endcapcoolingtubeshape[0]->GetDz());
5540 torustuberot[5]->SetAngles(0.,90.,0.);
5541 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5542 torustuberot[6]->SetAngles(-90.,0.,0.);
5543 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5544 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5545
5546 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5547 endcapcoolingtubeshape[3]->GetDz(),0.);
5548 coolingtuberot[6]->SetAngles(0.,90.,0.);
5549 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5550 *coolingtuberot[6]);
5551 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5552 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5553 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5554 /////////////////////////////////////////
5555 // Transformation for Water Volume Positioning
5556 /////////////////////////////////////////
5557 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5558 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5559 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5560 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5561 *coolingwatertuberot[0]);
5562
5563 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5564 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5565 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5566 *coolingwatertuberot[1]);
5567
5568 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5569 *CosD(fgkEndCapCoolingTubeAngle[0]),
5570 fgkEndCapCoolingTubeAxialRadius[0]
5571 *SinD(fgkEndCapCoolingTubeAngle[0]),
5572 0.);
5573 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5574 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5575 *coolingwatertuberot[2]);
5576
5577 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5578 * (*coolingwatertubecombitrans[1]));
5579
5580 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5581 endcapcoolingwatertubeshape[1]->GetDz());
5582 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5583 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5584 *toruswatertuberot[0]);
5585
5586 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5587 * (*toruswatertubecombitrans[0]));
5588
5589 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5590 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5591 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5592 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5593 *coolingwatertuberot[3]);
5594 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5595 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5596 * (*coolingwatertubecombitrans[3]));
5597 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5598
5599 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5600 endcapcoolingwatertubeshape[2]->GetDz());
5601 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5602 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5603 *toruswatertuberot[1]);
5604 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5605 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5606 * (*toruswatertubecombitrans[1]));
5607 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5608
5609 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5610 -fgkEndCapCoolingTubeAxialRadius[0]);
5611 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5612 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5613 *toruswatertuberot[3]);
5614 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5615 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5616 * (*toruswatertubecombitrans[2]));
5617 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5618
5619 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5620 fgkEndCapCoolingTubeAxialRadius[0],0.);
5621 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5622 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5623 *coolingwatertuberot[5]);
5624 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5625 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5626 * (*coolingwatertubecombitrans[4]));
5627 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5628
5629 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5630 endcapcoolingwatertubeshape[0]->GetDz());
5631 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5632 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5633 *toruswatertuberot[5]);
5634 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5635 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5636 * (*toruswatertubecombitrans[3]));
5637 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5638
5639 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5640 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5641 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5642 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5643 *coolingwatertuberot[6]);
5644 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5645 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5646 * (*coolingwatertubecombitrans[5]));
5647 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5648 /////////////////////////////////////////
5649 // Positioning Volumes
5650 /////////////////////////////////////////
5651 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5652 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5653
5654 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5655 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5656
5657 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5658 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5659
5660 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5661 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5662
5663 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5664 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5665
5666 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5667 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5668
5669 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5670 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5671
5672 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5673 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5674
5675 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5676 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5677
5678 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5679 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5680 /////////////////////////////////////////////////////////////
5681 // Deallocating memory
5682 /////////////////////////////////////////////////////////////
5683 for(Int_t i=0; i<8; i++){
5684 if(i<6){
5685 delete coolingtubetrans[i];
5686 delete coolingwatertubetrans[i];
5687 if(i!=0){
5688 delete coolingtubecombitrans[i];
5689 delete coolingwatertubecombitrans[i];
5690 }
5691 }
5692 if(i<8){
5693 delete coolingtuberot[i];
5694 delete coolingwatertuberot[i];
5695 }
5696 if(i<4){
5697 delete torustubetrans[i];
5698 delete toruswatertubetrans[i];
5699 delete torustubecombitrans[i];
5700 delete toruswatertubecombitrans[i];
5701 }
5702 if(i<7){
5703 delete torustuberot[i];
5704 delete toruswatertuberot[i];
5705 }
5706 }
5707 /////////////////////////////////////////////////////////////
5708 return endcapcoolingtubemother;
5709 }
5710 ////////////////////////////////////////////////////////////////////////////////
5711 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5712 /////////////////////////////////////////////////////////////
5713 // Getting EndCap Cover Side
5714 /////////////////////////////////////////////////////////////
5715 const Int_t kendcapcoverholenumber[2] = {7,5};
5716 const Int_t kvertexnumber = 15;
5717 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5718 xvertex[0] = 0.0;
5719 xvertex[1] = xvertex[0];
5720 xvertex[2] = fgkEndCapSideCoverLength[0];
5721 xvertex[3] = fgkEndCapSideCoverLength[1];
5722 xvertex[4] = xvertex[3];
5723 xvertex[5] = fgkEndCapSideCoverLength[2];
5724 xvertex[6] = xvertex[5];
5725 xvertex[7] = xvertex[2];
5726 xvertex[8] = xvertex[7];
5727 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5728 xvertex[10] = xvertex[9];
5729 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5730 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5731 * fgkEndCapSideCoverLength[4];
5732 xvertex[12] = xvertex[11];
5733 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5734 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5735 * fgkEndCapSideCoverLength[4];
5736 xvertex[14] = xvertex[13];
5737 yvertex[0] = 0.0;
5738 yvertex[1] = fgkEndCapSideCoverWidth[0];
5739 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5740 yvertex[3] = yvertex[2];
5741 yvertex[4] = fgkEndCapSideCoverWidth[1];
5742 yvertex[5] = yvertex[4];
5743 yvertex[6] = yvertex[0];
5744 yvertex[7] = yvertex[6];
5745 yvertex[8] = fgkEndCapSideCoverWidth[6];
5746 yvertex[9] = yvertex[8];
5747 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5748 yvertex[11] = yvertex[10];
5749 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5750 yvertex[13] = yvertex[12];
5751 yvertex[14] = yvertex[6];
5752 TGeoXtru* endcapsidecovershape = new TGeoXtru(2);
5753 endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex);
5754 endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5755 endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5756 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5757 endcapsidecovershape,fSSDCoolingTubePhynox);
5758 endcapsidecover->SetLineColor(fColorPhynox);
5759 ////////////////////////////////////////////
5760 // Defininition of Mother Volume
5761 ////////////////////////////////////////////
5762 const Int_t kmothervertexnumber = 7;
5763 Double_t xmothervertex[kmothervertexnumber];
5764 Double_t ymothervertex[kmothervertexnumber];
5765 for(Int_t i=0; i<kmothervertexnumber; i++){
5766 xmothervertex[i] = xvertex[i];
5767 ymothervertex[i] = yvertex[i];
5768 }
5769 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5770 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5771 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5772 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5773 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5774 endcapsidecovermothershape,fSSDAir);
5775 ////////////////////////////////////////////
5776 endcapsidecovermother->AddNode(endcapsidecover,1);
5777 TGeoBBox* endcapsidecoverboxshape[4];
5778 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5779 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5780 0.5*fgkEndCapSideCoverLength[4],
5781 0.5*fgkEndCapSideCoverThickness);
5782 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5783 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5784 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5785 - fgkEndCapSideCoverLength[4]),
5786 0.5*fgkEndCapSideCoverThickness);
5787 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5788 0.5*fgkEndCapSideCoverLength[4],
5789 0.5*fgkEndCapSideCoverThickness);
5790 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5791 0.5*fgkEndCapSideCoverWidth[5],
5792 0.5*fgkEndCapSideCoverThickness);
5793 TGeoVolume* endcapsidecoverbox[4];
5794 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5795 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5796 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5797 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5798 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5799// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5800 TGeoTranslation** endcapsidecoverboxtrans;
5801 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5802 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5803 + fgkEndCapSideCoverLength[0],
5804 endcapsidecoverboxshape[0]->GetDY()
5805 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5806 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5807 + xvertex[11],
5808 endcapsidecoverboxshape[1]->GetDY()
5809 + yvertex[12],0.);
5810 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5811 + xvertex[11],
5812 endcapsidecoverboxshape[2]->GetDY()
5813 + yvertex[12]
5814 + 2.*endcapsidecoverboxshape[1]->GetDY()
5815 + fgkEndCapSideCoverWidth[5],0.);
5816 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5817 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5818 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5819 for(Int_t i=0; i<2; i++)
5820 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5821 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5822 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5823 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5824 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5825 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5826 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5827 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5828 }
5829 for(Int_t i=0; i<2; i++)
5830 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5831 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5832 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5833 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5834 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5835 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5836 +fgkEndCapSideCoverLength[4]),0.0);
5837 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5838 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5839 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5840 +i*(kendcapcoverholenumber[1]-1)+j]);
5841 }
5842 return endcapsidecovermother;
5843 }
5844 ////////////////////////////////////////////////////////////////////////////////
5845 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5846 ////////////////////////////////////////////////////////////////////////////////
5847 // Method returning Interface Card A, Interface Card B, Supply Card
5848 ////////////////////////////////////////////////////////////////////////////////
5849 /////////////////////
5850 // Supply Card
5851 /////////////////////
5852 // Electronic Board Back Al Plane
5853 const Int_t kelectboardbackvertexnumber = 8;
5854 Double_t xelectboardback[kelectboardbackvertexnumber];
5855 Double_t yelectboardback[kelectboardbackvertexnumber];
5856 xelectboardback[0] = 0.0;
5857 xelectboardback[1] = xelectboardback[0];
5858 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5859 xelectboardback[3] = xelectboardback[2];
5860 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5861 xelectboardback[5] = xelectboardback[4];
5862 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5863 xelectboardback[7] = xelectboardback[6];
5864
5865 yelectboardback[0] = 0.0;
5866 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5867 yelectboardback[2] = yelectboardback[1];
5868 yelectboardback[3] = yelectboardback[0];
5869 yelectboardback[4] = yelectboardback[3];
5870 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5871 yelectboardback[6] = yelectboardback[5];
5872 yelectboardback[7] = yelectboardback[4];
5873 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5874 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5875 xelectboardback,yelectboardback);
5876 electboardbackshape->DefineSection(0,0.0);
5877 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5878 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5879 electboardbackshape,fSSDSupportRingAl);
5880 electboardback->SetLineColor(fColorAl);
5881 // Electronic Board Kapton Layer
5882 const Int_t kelectlayervertexnumber = 8;
5883 Double_t xelectlayer[kelectlayervertexnumber];
5884 Double_t yelectlayer[kelectlayervertexnumber];
5885 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5886 xelectlayer[1] = xelectlayer[0];
5887 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5888 xelectlayer[3] = xelectlayer[2];
5889 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5890
5891 yelectlayer[0] = 0.0;
5892 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5893 yelectlayer[2] = yelectlayer[1];
5894 yelectlayer[3] = yelectlayer[0];
5895 yelectlayer[4] = yelectlayer[3];
5896 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5897 yelectlayer[6] = yelectlayer[5];
5898 yelectlayer[7] = yelectlayer[4];
5899 TGeoXtru* electlayershape = new TGeoXtru(2);
5900 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5901 electlayershape->DefineSection(0,0.0);
5902 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5903 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5904 electlayershape,fSSDKaptonFlexMedium);
5905 electlayer->SetLineColor(fColorKapton);
5906 // JMD Connector Female
5907 const Int_t kjmdconnectorvertexnumber = 6;
5908 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5909 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5910 xjmdconnectorvertex[0] = 0.0;
5911 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5912 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5913 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5914 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5915 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5916
5917 yjmdconnectorvertex[0] = 0.0;
5918 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5919 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5920 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5921 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5922 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5923 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5924 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5925 yjmdconnectorvertex);
5926 jmdconnectorshape->DefineSection(0,0.0);
5927 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5928 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5929 jmdconnectorshape,fSSDMountingBlockMedium);
5930 jmdconnector->SetLineColor(fColorG10);
5931 // Top Cable Connector
5932 const Int_t kcableconnectorvertexnumber = 8;
5933 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5934 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5935 xconnectorvertex[0] = 0.0;
5936 xconnectorvertex[1] = xconnectorvertex[0];
5937 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5938 xconnectorvertex[3] = xconnectorvertex[2];
5939 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5940 - fgkEndCapCardCableConnectorLength[2];
5941 xconnectorvertex[5] = xconnectorvertex[4];
5942 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5943 xconnectorvertex[7] = xconnectorvertex[6];
5944
5945 yconnectorvertex[0] = 0.0;
5946 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5947 yconnectorvertex[2] = yconnectorvertex[1];
5948 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5949 yconnectorvertex[4] = yconnectorvertex[3];
5950 yconnectorvertex[5] = yconnectorvertex[1];
5951 yconnectorvertex[6] = yconnectorvertex[5];
5952 yconnectorvertex[7] = yconnectorvertex[0];
5953 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5954 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5955 yconnectorvertex);
5956 cableconnectorshape->DefineSection(0,0.0);
5957 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5958 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5959 cableconnectorshape,fSSDMountingBlockMedium);
5960 cableconnector->SetLineColor(fColorG10);
5961 // Strip Connection
5962 TGeoBBox* endcapstripconnectionshape =
5963 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5964 0.5*fgkEndCapStripConnectionThickness,
5965 0.5*fgkEndCapStripConnectionWidth);
5966 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5967 endcapstripconnectionshape,
5968 fSSDSupportRingAl);
5969 endcapstripconnection->SetLineColor(fColorAl);
5970 // Interface Card B
5971 const Int_t kcardBvertexnumber = 12;
5972 Double_t xcardBvertexnumber[kcardBvertexnumber];
5973 Double_t ycardBvertexnumber[kcardBvertexnumber];
5974
5975 xcardBvertexnumber[0] = 0.0;
5976 xcardBvertexnumber[1] = xcardBvertexnumber[0];
5977 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5978 xcardBvertexnumber[3] = xcardBvertexnumber[2];
5979 xcardBvertexnumber[4] = xcardBvertexnumber[1];
5980 xcardBvertexnumber[5] = xcardBvertexnumber[4];
5981 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5982 xcardBvertexnumber[7] = xcardBvertexnumber[6];
5983 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5984 xcardBvertexnumber[9] = xcardBvertexnumber[8];
5985 xcardBvertexnumber[10] = xcardBvertexnumber[7];
5986 xcardBvertexnumber[11] = xcardBvertexnumber[10];
5987
5988 ycardBvertexnumber[0] = 0.0;
5989 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
5990 ycardBvertexnumber[2] = ycardBvertexnumber[1];
5991 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5992 ycardBvertexnumber[4] = ycardBvertexnumber[3];
5993 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5994 ycardBvertexnumber[6] = ycardBvertexnumber[5];
5995 ycardBvertexnumber[7] = ycardBvertexnumber[4];
5996 ycardBvertexnumber[8] = ycardBvertexnumber[7];
5997 ycardBvertexnumber[9] = ycardBvertexnumber[1];
5998 ycardBvertexnumber[10] = ycardBvertexnumber[9];
5999 ycardBvertexnumber[11] = ycardBvertexnumber[0];
6000
6001 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
6002 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
6003 interfacecardBshape->DefineSection(0,0.);
6004 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
6005 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
6006 fSSDMountingBlockMedium);
6007 interfacecardB->SetLineColor(46);
6008 // Interface Card B Electronic Board
6009 const Int_t kelectboardcardBvertexnumber = 14;
6010 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
6011 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
6012
6013 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
6014 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
6015 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
6016 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
6017 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
6018 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
6019 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6020 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
6021 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6022 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
6023 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6024 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6025 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6026 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6027
6028 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6029 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6030 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
6031 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6032 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
6033 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
6034 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
6035 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6036 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
6037 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6038 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6039 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6040 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6041 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6042
6043 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6044 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6045 xelectboardcardBvertex,yelectboardcardBvertex);
6046 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6047 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6048 + fgkEndCapInterfaceElectBoardCardBThickness);
6049 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6050 fSSDSupportRingAl);
6051 electboardcardB->SetLineColor(fColorAl);
6052 // Generating Stiffener 2
6053 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6054 0.5*fgkEndCapStiffenerThickness,
6055 0.5*fgkEndCapStiffenerLength);
6056 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6057 endcapstiffener->SetLineColor(fColorAl);
6058 // Generating Mother Interface Card B Container
6059 const Int_t kinterfacecardBmothervertexnumber = 10;
6060 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6061 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6062
6063 xinterfacecardBmothervertex[0] = 0.0;
6064 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6065 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6066 + fgkEndCapInterfaceCardBThickness;
6067 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6068 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6069 + fgkEndCapInterfaceElectBoardCardBThickness;
6070 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6071 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6072 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6073 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6074 + fgkEndCapCardJMDConnectorLength[0];
6075 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6076
6077 yinterfacecardBmothervertex[0] = 0.0;
6078 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6079 + fgkEndCapInterfaceCardBWidth[1]
6080 + fgkEndCapInterfaceCardBWidth[2];
6081 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6082 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6083 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6084 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6085 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6086 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6087 + fgkEndCapCardJMDConnectorWidth[0]
6088 + fgkEndCapCardJMDConnectorWidth[1];
6089 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6090 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6091 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6092 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6093 xinterfacecardBmothervertex,
6094 yinterfacecardBmothervertex);
6095 interfacecardBmothershape->DefineSection(0,-1.e-15);
6096 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6097 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6098 interfacecardBmothershape,fSSDAir);
6099 electboardcardB->SetLineColor(fColorAl);
6100 // Positioning Volumes Mother Interface Card B Container
6101 TGeoRotation* interfacecardBrot = new TGeoRotation();
6102 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6103 interfacecardBrot->SetAngles(90.,-90.,-90.);
6104 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6105 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6106 TGeoRotation* electboardcardBrot = new TGeoRotation();
6107 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6108 electboardcardBrot->SetAngles(90.,90.,-90.);
6109 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6110 TGeoCombiTrans* electboardcardBcombitrans =
6111 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6112 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6113 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6114 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6115 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6116 TGeoTranslation* jmdconnectorcardBtrans[3];
6117 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6118 for(Int_t i=0; i<3; i++){
6119 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6120 + fgkEndCapCardJMDConnectorLength[0],
6121 fgkEndCapCardElectBoardLayerWidth[1],
6122 0.5*fgkEndCapCardJMDConnectorThickness
6123 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6124 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6125 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6126 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6127 *jmdconnectorcardBrot);
6128 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6129 }
6130 // Mother Supply Card Container
6131 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6132 // Interface Card Container
6133 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6134 // Placing Volumes in Mother Supply Card Container
6135 // JMD Connector Positioning
6136 TGeoTranslation* jmdconnectortrans[2];
6137 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6138 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6139 fgkEndCapCardElectBoardBackLength[0]
6140 - fgkEndCapCardJMDConnectorThickness
6141 - fgkEndCapCardJMDConnectorToLayer);
6142 TGeoRotation* jmdconnectorot = new TGeoRotation();
6143 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6144 + 2.*fgkEndCapCardJMDConnectorLength[0]
6145 + 2.*fgkEndCapCardElectBoardLayerThickness,
6146 fgkEndCapCardElectBoardLayerWidth[1],
6147 fgkEndCapCardJMDConnectorThickness
6148 + fgkEndCapCardJMDConnectorToLayer);
6149 jmdconnectorot->SetAngles(90.,180.,-90);
6150 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6151 * jmdconnectorot);
6152 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6153 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6154 // Top Cable Connector Placing
6155 TGeoRotation* cableconnectorot[2];
6156 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6157 TGeoTranslation* cableconnectortrans[3];
6158 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6159 cableconnectorot[0]->SetAngles(90.,0.,0.);
6160 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6161 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6162 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6163 *cableconnectorot[0]);
6164 TGeoHMatrix* cableconnectormatrix[2];
6165 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6166 new TGeoHMatrix((*cableconnectorot[1])
6167 *(*cableconnectorcombitrans));
6168 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6169 - fgkEndCapCardCableConnectorThickness,
6170 fgkEndCapCardCableConnectorLength[0]
6171 + fgkEndCapCardCableConnectorToLayer);
6172 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6173 - 2.*fgkEndCapCardCableConnectorThickness
6174 - fgkEndCapCardCableConnectorDistance,
6175 fgkEndCapCardCableConnectorLength[0]
6176 + fgkEndCapCardCableConnectorToLayer);
6177 for(Int_t i=0; i<2; i++){
6178 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6179 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6180 }
6181 TGeoRotation* electboardbackrot = new TGeoRotation();
6182 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6183 electboardbackrot->SetAngles(90.,-90.,-90.);
6184 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6185 + fgkEndCapCardJMDConnectorLength[0]
6186 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6187 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6188 *electboardbackrot);
6189 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6190 // Electronic Board Kapton Layer Positioning
6191 TGeoRotation* electlayerrot = new TGeoRotation();
6192 TGeoTranslation* electlayertrans[2];
6193 TGeoCombiTrans* electlayercombitrans[2];
6194 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6195 electlayerrot->SetAngles(90.,-90.,-90.);
6196 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6197 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6198 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6199 + 2.*fgkEndCapCardElectBoardLayerThickness
6200 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6201 for(Int_t i=0; i<2; i++){
6202 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6203 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6204 }
6205 // Placing Volumes in Mother Interface Card Container
6206 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6207 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6208 for(Int_t i=0; i<2; i++){
6209 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6210 }
6211 /////////////////////////////////////////////////////////////
6212 // Generation of Card Interface Container
6213 /////////////////////////////////////////////////////////////
6214 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6215 - fgkEndCapCardJMDConnectorLength[0]
6216 - fgkEndCapInterfaceCardBThickness
6217 - 9.*fgkEndCapStripConnectionThickness
6218 - 8.*fgkEndCapCardElectBoardBackThickness;
6219 const Int_t kcardinterfacecontainervertexnumber = 14;
6220 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6221 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6222 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6223 - 7.0*fgkEndCapStripConnectionThickness;
6224 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6225 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6226 + fgkEndCapStripConnectionThickness
6227 - fgkEndCapCardElectBoardLayerThickness
6228 - fgkEndCapCardCableConnectorWidth[0];
6229 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6230 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6231 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6232 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6233 + 2.0*fgkEndCapStripConnectionThickness;
6234 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6235 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6236 + fgkEndCapInterfaceCardBThickness;
6237 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6238 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6239 + fgkEndCapInterfaceElectBoardCardBThickness;
6240 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6241 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6242 - fgkEndCapInterfaceElectBoardCardBThickness
6243 + fgkEndCapCardJMDConnectorLength[0]
6244 + stiffenertransx+fgkEndCapStiffenerWidth;
6245 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6246
6247 ycardinterfacecontainervertex[0] = 0.;
6248 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6249 + fgkEndCapCardJMDConnectorWidth[0]
6250 + fgkEndCapCardJMDConnectorWidth[1];
6251 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6252 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6253 - fgkEndCapStripConnectionWidth;
6254 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6255 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6256 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6257 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6258 + fgkEndCapInterfaceCardBWidth[1]
6259 + fgkEndCapInterfaceCardBWidth[2];
6260 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6261 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6262 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6263 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6264 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6265 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6266
6267 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6268 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6269 xcardinterfacecontainervertex,
6270 ycardinterfacecontainervertex);
6271 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6272 - fgkEndCapCardElectBoardBackLength[0]));
6273 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6274 + fgkEndCapCardElectBoardBackLength[0]));
6275 TGeoVolume** cardinterfacecontainer;
6276 cardinterfacecontainer = new TGeoVolume*[4];
6277 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6278 interfacecardmothershape,fSSDAir);
6279 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6280 interfacecardmothershape,fSSDAir);
6281 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6282 interfacecardmothershape,fSSDAir);
6283 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6284 interfacecardmothershape,fSSDAir);
6285 /////////////////////////////////
6286 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6287 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6288 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6289 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6290 /////////////////////////////////
6291 TGeoRotation* endcapstripconnectionrot[2];
6292 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6293 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6294 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6295 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6296 * (*endcapstripconnectionrot[0]));
6297 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6298 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6299 -0.5*fgkEndCapCardElectBoardBackThickness,
6300 fgkEndCapCardElectBoardBackWidth[0]
6301 -endcapstripconnectionshape->GetDZ(),
6302 0.5*fgkEndCapCardElectBoardBackLength[0]);
6303 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6304 TGeoTranslation* cardinterfacetrans[9];
6305 TGeoHMatrix* cardinterfacematrix[9];
6306 for(Int_t i=0; i<7; i++){
6307 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6308 + fgkEndCapCardElectBoardBackThickness),
6309 0.0,0.0);
6310 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6311 * (*endcapstripconnectionmatrix));
6312 }
6313 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6314 + fgkEndCapCardElectBoardBackThickness),
6315 0.0,0.0);
6316 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6317 * (*endcapstripconnectionmatrix));
6318 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6319 + fgkEndCapCardElectBoardBackThickness),
6320 0.0,0.0);
6321 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6322 * (*endcapstripconnectionmatrix));
6323
6324 for(Int_t i=0; i<4; i++){
6325 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6326 cardinterfacematrix[7]);
6327 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6328 cardinterfacematrix[8]);
6329 }
6330 TGeoTranslation* mothersupplycardtrans =
6331 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6332 + 2.*fgkEndCapCardJMDConnectorLength[0]
6333 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6334 TGeoHMatrix* mothersupplycardmatrix[7];
6335 Int_t index[4] = {1,1,1,1};
6336 for(Int_t i=0; i<7; i++){
6337 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6338 * (*mothersupplycardtrans));
6339 for(Int_t j=0; j<4; j++){
6340 switch(j){
6341 case 0: //Layer5 EndCap Left Side
6342 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6343 cardinterfacematrix[i]);
6344 if(i!=0){
6345 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6346 mothersupplycardmatrix[i]);
6347 index[j]++;
6348
6349 }
6350 break;
6351 case 1: //Layer5 EndCap Rigth Side
6352 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6353 cardinterfacematrix[i]);
6354 if(i>0&&i<6){
6355 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6356 mothersupplycardmatrix[i]);
6357 index[j]++;
6358 }
6359 break;
6360 case 2: //Layer6 EndCap Left Side
6361 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6362 cardinterfacematrix[i]);
6363 if(i!=6){
6364 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6365 mothersupplycardmatrix[i]);
6366 index[j]++;
6367 }
6368 break;
6369 case 3: //Layer6 EndCap Right Side
6370 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6371 cardinterfacematrix[i]);
6372 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6373 mothersupplycardmatrix[i]);
6374 index[j]++;
6375 break;
6376 }
6377 }
6378 }
6379 // Positioning Interface
6380 TGeoTranslation* motherinterfacecardtrans =
6381 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6382 +0.5*fgkEndCapCardElectBoardBackThickness
6383 -fgkEndCapCardElectBoardLayerThickness
6384 +fgkEndCapStripConnectionThickness,0.,0.);
6385 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6386 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6387 // Positioning Interface Card B
6388 TGeoTranslation* interfacecardBmothertrans =
6389 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6390 + 2.*fgkEndCapStripConnectionThickness
6391 + fgkEndCapCardElectBoardBackThickness,0.,
6392 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6393 - fgkEndCapCardElectBoardBackLength[0]));
6394 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6395 interfacecardBmothertrans);
6396 // Positioning Stiffener
6397 TGeoTranslation* endcapstiffenertrans =
6398 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6399 + 2.0*fgkEndCapStripConnectionThickness
6400 + fgkEndCapInterfaceCardBThickness
6401 + fgkEndCapCardJMDConnectorLength[0]
6402 + stiffenertransx
6403 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6404 endcapstiffenershape->GetDZ()
6405 - 0.5*(fgkEndCapStiffenerLength
6406 - fgkEndCapCardElectBoardBackLength[0]));
6407 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6408 /////////////////////////////////////////////////////////////
6409 // Deallocating memory
6410 /////////////////////////////////////////////////////////////
6411 delete interfacecardBrot;
6412 delete interfacecardBtrans;
6413 delete electboardcardBtrans;
6414 delete electboardcardBrot;
6415 delete jmdconnectorcardBrot;
6416 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6417 delete jmdconnectorot;
6418 delete jmdconnectortrans[1];
6419 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6420 delete cableconnectorcombitrans;
6421 delete electboardbacktrans;
6422 delete electboardbackrot;
6423 delete electlayerrot;
6424 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6425 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6426 delete mothersupplycardtrans;
6427 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6428 /////////////////////////////////////////////////////////////
6429 return cardinterfacecontainer;
6430 }
6431 ////////////////////////////////////////////////////////////////////////////////
6432 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6433 /////////////////////////////////////////////////////////////
6434 // Method returning EndCap Mother Volume
6435 /////////////////////////////////////////////////////////////
6436 const Int_t kendcapcoverplatesmallholenumber = 9;
6437 Double_t endcapmotherorigin[3];
6438 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6439 + 0.5 *(fgkEndCapCoverPlateLength[3]
6440 + 2.0 * fgkEndCapCoverPlateLength[2]);
6441 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6442 - fgkEndCapCoverPlateWidth[2]
6443 - (kendcapcoverplatesmallholenumber-1)
6444 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6445 + 0.5*(fgkEndCapSideCoverLength[2]
6446 + fgkEndCapCoverPlateWidth[1]
6447 - fgkEndCapCoverPlateWidth[0])
6448 - (fgkEndCapCoverPlateWidth[1]
6449 - fgkEndCapCoverPlateWidth[0]);
6450 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6451 + 2.*fgkEndCapCoolingTubeRadiusMax
6452 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6453 + fgkEndCapSideCoverWidth[1]
6454 + fgkEndCapSideCoverThickness
6455 + fgkEndCapKaptonFoilThickness);
6456 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6457 + 2.0* fgkEndCapCoverPlateLength[2]
6458 + 2.0* fgkEndCapSideCoverThickness),
6459 0.5* (fgkEndCapSideCoverLength[2]
6460 + fgkEndCapCoverPlateWidth[1]
6461 - fgkEndCapCoverPlateWidth[0]),
6462 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6463 + fgkEndCapSideCoverWidth[1]
6464 + fgkEndCapSideCoverThickness
6465 + fgkEndCapKaptonFoilThickness),
6466 endcapmotherorigin);
6467 TGeoVolume** endcapassembly;
6468 endcapassembly = new TGeoVolume*[4];
6469 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6470 endcapmothershape,fSSDAir);
6471 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6472 endcapmothershape,fSSDAir);
6473 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6474 endcapmothershape,fSSDAir);
6475 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6476 endcapmothershape,fSSDAir);
6477 /////////////////////////////////
6478 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6479 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6480 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6481 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6482 /////////////////////////////////
6483 /////////////////////////////////////////////////////
6484 // Placing Endcap Cover Plate
6485 /////////////////////////////////////////////////////
6486 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6487 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6488 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6489 TGeoCombiTrans* endcapcoverplatecombitrans =
6490 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6491 endcapcoverplaterot);
6492 TGeoTranslation* endcapcoverplatetrans =
6493 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6494 TGeoHMatrix* endcapcoverplatematrix =
6495 new TGeoHMatrix((*endcapcoverplatetrans)
6496 * (*endcapcoverplatecombitrans));
6497 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6498 /////////////////////////////////////////////////////
6499 // Placing Endcap Side Cover
6500 /////////////////////////////////////////////////////
6501 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6502 TGeoRotation* endcapsidecoverot[2];
6503 TGeoCombiTrans* endcapsidecovercombitrans[3];
6504 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6505 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6506 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6507 - 0.5*(fgkEndCapCoverPlateWidth[0]
6508 - fgkEndCapCoverPlateWidth[2]
6509 - (kendcapcoverplatesmallholenumber-1)
6510 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6511 + 0.*fgkEndCapCoverPlateWidth[0]
6512 + fgkEndCapSideCoverLength[2],
6513 0.5*(fgkEndCapSideCoverThickness
6514 + fgkEndCapCoverPlateThickness)
6515 - 0.5*fgkEndCapCoverPlateThickness,
6516 endcapsidecoverot[0]);
6517 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6518 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6519 0.5*fgkEndCapCoverPlateThickness
6520 -fgkEndCapSideCoverWidth[1],
6521 endcapsidecoverot[1]);
6522 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6523 +fgkEndCapCoverPlateLength[3]
6524 +2.*fgkEndCapCoverPlateLength[2]
6525 +fgkEndCapSideCoverThickness,0.0,
6526 0.5*fgkEndCapCoverPlateThickness
6527 -fgkEndCapSideCoverWidth[1],
6528 endcapsidecoverot[1]);
6529 TGeoHMatrix* endcapsidecovermatrix[2];
6530 for(Int_t i=0; i<2; i++){
6531 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6532 * (*endcapsidecovercombitrans[0]));
6533 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6534 endcapsidecovermatrix[i]);
6535 }
6536 /////////////////////////////////////////////////////
6537 // Placing Endcap Cooling Tube
6538 /////////////////////////////////////////////////////
6539 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6540 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6541 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6542 TGeoCombiTrans* endcapccolingtubecombitrans
6543 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6544 + fgkEndCapCoolingTubeAxialRadius[1])
6545 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6546 - fgkEndCapCoolingTubeToCoverSide,
6547 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6548 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6549 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6550 endcapccolingtubecombitrans);
6551 /////////////////////////////////////////////////////
6552 // Placing Screws
6553 /////////////////////////////////////////////////////
6554 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6555 fgkEndCapCoverPlateScrewRadiusMin};
6556 Int_t screwcoverplatedgesnumber[2] = {20,20};
6557 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6558 fgkEndCapCoverPlateThickness
6559 + fgkEndCapCoolingTubeRadiusMax};
6560 TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6561 screwcoverplatedgesnumber,
6562 screwcoverplatesection);
6563 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6564 screwcoverplateshape,
6565 fSSDCoolingTubePhynox);
6566 screwcoverplate->SetLineColor(12);
6567 Double_t transx[4] = {0,
6568 fgkEndCapCoverPlateSmallHoleSeparation[0],
6569 fgkEndCapCoverPlateSmallHoleSeparation[0]
6570 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6571 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6572 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6573 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6574// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6575 TGeoTranslation*** endcapcoverplatescrewtrans;
6576 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6577 Int_t index = 0;
6578 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6579 endcapcoverplatescrewtrans[i] =
6580 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6581 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6582 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6583 if(index==1||index==9||index==28||index==36){
6584 endcapcoverplatescrewtrans[i][j] =
6585 new TGeoTranslation(transx[i],
6586 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6587 fgkEndCapSideCoverThickness);
6588 }
6589 else{
6590 endcapcoverplatescrewtrans[i][j] =
6591 new TGeoTranslation(transx[i],
6592 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6593 0.);
6594 }
6595 if(index!=19)
6596 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6597 endcapcoverplatescrewtrans[i][j]);
6598 }
6599 }
6600 /////////////////////////////////////////////////////
6601 // Placing Cover Plate Clips
6602 /////////////////////////////////////////////////////
6603 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6604 0.5*fgkEndCapCoverPlateClipWidth,
6605 0.5*fgkEndCapSideCoverThickness);
6606 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6607 endcapcoverplateclipshape,
6608 fSSDCoolingTubePhynox);
6609 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6610 0.5*fgkEndCapCoverPlateDownClipWidth,
6611 0.5*fgkEndCapSideCoverThickness);
6612 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6613 endcapcoverplatedownclipshape,
6614 fSSDCoolingTubePhynox);
6615 TGeoTranslation* endcapcoverplatecliptrans[4];
6616 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6617 - fgkEndCapCoverPlateLength[0]
6618 - fgkEndCapSideCoverThickness,
6619 0.0,
6620 0.5*(fgkEndCapSideCoverThickness
6621 + fgkEndCapCoverPlateThickness));
6622 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6623 - fgkEndCapCoverPlateLength[0]
6624 - fgkEndCapSideCoverThickness,
6625 (kendcapcoverplatescrewnumber[1]-1)
6626 * fgkEndCapSideCoverWidth[5],
6627 0.5*(fgkEndCapSideCoverThickness
6628 + fgkEndCapCoverPlateThickness));
6629 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6630 - fgkEndCapCoverPlateLength[0]
6631 + fgkEndCapCoverPlateLength[1]
6632 + 2.*fgkEndCapCoverPlateLength[0]
6633 - fgkEndCapCoverPlateClipLength
6634 + fgkEndCapSideCoverThickness,
6635 0.0,
6636 0.5*(fgkEndCapSideCoverThickness
6637 + fgkEndCapCoverPlateThickness));
6638 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6639 - fgkEndCapCoverPlateLength[0]
6640 + fgkEndCapCoverPlateLength[1]
6641 + 2.*fgkEndCapCoverPlateLength[0]
6642 - fgkEndCapCoverPlateClipLength
6643 + fgkEndCapSideCoverThickness,
6644 (kendcapcoverplatescrewnumber[1]-1)
6645 * fgkEndCapSideCoverWidth[5],
6646 0.5*(fgkEndCapSideCoverThickness
6647 + fgkEndCapCoverPlateThickness));
6648 endcapcoverplateclip->SetLineColor(fColorPhynox);
6649 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6650 for(Int_t i=0; i<4; i++)
6651 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6652 endcapcoverplatecliptrans[i]);
6653 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6654 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6655 - fgkEndCapCoverPlateLength[0]
6656 - fgkEndCapSideCoverThickness,
6657 0.5*(fgkEndCapCoverPlateDownClipWidth
6658 - fgkEndCapCoverPlateClipWidth),
6659 0.5*(fgkEndCapSideCoverThickness
6660 + fgkEndCapCoverPlateThickness)
6661 - fgkEndCapSideCoverWidth[1]
6662 - fgkEndCapSideCoverThickness);
6663 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6664 - fgkEndCapCoverPlateLength[0]
6665 - fgkEndCapSideCoverThickness,
6666 0.5*(fgkEndCapCoverPlateDownClipWidth
6667 - fgkEndCapCoverPlateClipWidth)
6668 + fgkEndCapSideCoverLength[2]
6669 - fgkEndCapCoverPlateDownClipWidth,
6670 0.5*(fgkEndCapSideCoverThickness
6671 + fgkEndCapCoverPlateThickness)
6672 - fgkEndCapSideCoverWidth[1]
6673 - fgkEndCapSideCoverThickness);
6674 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6675 - fgkEndCapCoverPlateLength[0]
6676 + fgkEndCapSideCoverThickness
6677 + fgkEndCapCoverPlateLength[1]
6678 + 2.0*fgkEndCapCoverPlateLength[0]
6679 - fgkEndCapCoverPlateDownClipLength,
6680 0.5*(fgkEndCapCoverPlateDownClipWidth
6681 - fgkEndCapCoverPlateClipWidth),
6682 0.5*(fgkEndCapSideCoverThickness
6683 + fgkEndCapCoverPlateThickness)
6684 - fgkEndCapSideCoverWidth[1]
6685 - fgkEndCapSideCoverThickness);
6686 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6687 - fgkEndCapCoverPlateLength[0]
6688 + fgkEndCapSideCoverThickness
6689 + fgkEndCapCoverPlateLength[1]
6690 + 2.0*fgkEndCapCoverPlateLength[0]
6691 - fgkEndCapCoverPlateDownClipLength,
6692 0.5*(fgkEndCapCoverPlateDownClipWidth
6693 - fgkEndCapCoverPlateClipWidth)
6694 + fgkEndCapSideCoverLength[2]
6695 - fgkEndCapCoverPlateDownClipWidth,
6696 0.5*(fgkEndCapSideCoverThickness
6697 + fgkEndCapCoverPlateThickness)
6698 - fgkEndCapSideCoverWidth[1]
6699 - fgkEndCapSideCoverThickness);
6700 for(Int_t i=0; i<4; i++)
6701 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6702 endcapcoverplatedowncliptrans[i]);
6703 /////////////////////////////////////////////////////
6704 // Placing Kapton Foil
6705 /////////////////////////////////////////////////////
6706 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6707 0.5*fgkEndCapKaptonFoilWidth,
6708 0.5*fgkEndCapKaptonFoilThickness);
6709 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6710 endcapkaptonfoilshape,
6711 fSSDKaptonFlexMedium);
6712 endcapkaptonfoil->SetLineColor(8);
6713 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6714 0.5*fgkEndCapKaptonFoilWidth
6715 - 0.5*fgkEndCapCoverPlateClipWidth,
6716 0.5*fgkEndCapCoverPlateThickness
6717 - 0.5*fgkEndCapKaptonFoilThickness
6718 - fgkEndCapSideCoverWidth[1]
6719 - fgkEndCapSideCoverThickness);
6720 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6721 /////////////////////////////////////////////////////////////
6722 // Placing Electronic Tubes
6723 /////////////////////////////////////////////////////////////
6724 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6725 - fgkEndCapInterfaceCardBThickness
6726 - 9.*fgkEndCapStripConnectionThickness
6727 - 8.*fgkEndCapCardElectBoardBackThickness,
6728 fgkEndCapKaptonFoilWidth
6729 - fgkEndCapInterfaceCardBThickness
6730 - 9.*fgkEndCapStripConnectionThickness
6731 - 8.*fgkEndCapCardElectBoardBackThickness
6732 - fgkEndCapInterfaceElectBoardCardBThickness};
6733 TGeoVolume* endcapeffectivecables[2];
6734 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6735 fgkEndCapEffectiveCableRadiusMax,
6736 endcapeffectivecableswidth[0],
6737 10,"EndCapEffectiveCables1");
6738 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6739 fgkEndCapEffectiveCableRadiusMax,
6740 endcapeffectivecableswidth[1],
6741 25,"EndCapEffectiveCables2");
6742 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6743 TGeoTranslation* endcapeffectivecablestrans[2];
6744 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6745 - 0.5*endcapeffectivecableswidth[0]
6746 - 0.5*(fgkEndCapCoverPlateWidth[0]
6747 - fgkEndCapCoverPlateWidth[2]
6748 - (kendcapcoverplatesmallholenumber-1)
6749 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6750 + fgkEndCapSideCoverLength[2],
6751 - 0.5*fgkEndCapCoverPlateThickness
6752 - (fgkEndCapCardElectBoardBackWidth[0]
6753 - fgkEndCapInterfaceCardBWidth[0]
6754 - fgkEndCapInterfaceCardBWidth[1]));
6755 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6756 - 0.5*endcapeffectivecableswidth[1]
6757 - 0.5*(fgkEndCapCoverPlateWidth[0]
6758 - fgkEndCapCoverPlateWidth[2]
6759 - (kendcapcoverplatesmallholenumber-1)
6760 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6761 + fgkEndCapSideCoverLength[2],
6762 - 0.5*fgkEndCapCoverPlateThickness
6763 - (fgkEndCapCardElectBoardBackWidth[0]
6764 - fgkEndCapInterfaceCardBWidth[0])
6765 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6766 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6767 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6768 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6769 *endcapeffectivecablesrot);
6770 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6771 *endcapeffectivecablesrot);
6772 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6773 endcapeffectivecablescombitrans[0]);
6774 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6775 endcapeffectivecablescombitrans[1]);
6776 /////////////////////////////////////////////////////////////
6777 // Placing End Cap Cards
6778 /////////////////////////////////////////////////////////////
6779 TGeoVolume** endcapcards = GetEndCapCards();
6780 TGeoRotation* endcapcardsrot[2];
6781 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6782 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6783 TGeoTranslation* endcapcardstrans[2];
6784 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6785 - fgkEndCapCardElectBoardBackLength[0]));
6786 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6787 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6788 TGeoHMatrix* endcapcardsmatrix[2];
6789 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6790 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6791 - fgkEndCapCardJMDConnectorLength[0]
6792 - fgkEndCapInterfaceCardBThickness
6793 - 9.*fgkEndCapStripConnectionThickness
6794 - 8.*fgkEndCapCardElectBoardBackThickness;
6795 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6796 - fgkEndCapCoverPlateLength[0]
6797 + 0.5 * (fgkEndCapCoverPlateLength[3]
6798 + 2.0 * fgkEndCapCoverPlateLength[2]),
6799 - stiffenertransx-fgkEndCapStiffenerWidth
6800 - fgkEndCapCardJMDConnectorLength[0]
6801 - fgkEndCapInterfaceCardBThickness
6802 - 2.0 * fgkEndCapStripConnectionThickness
6803 - 1.5 * fgkEndCapInterfaceCardBThickness
6804 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6805 - fgkEndCapCoverPlateWidth[2]
6806 - (kendcapcoverplatesmallholenumber-1)
6807 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6808 + fgkEndCapKaptonFoilWidth,
6809 0.5*fgkEndCapCoverPlateThickness
6810 - fgkEndCapSideCoverWidth[1]);
6811 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6812 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6813 /////////////////////////////////////////////////////////////
6814 // Deallocating memory
6815 /////////////////////////////////////////////////////////////
6816 delete endcapcoverplaterot;
6817 delete endcapcoverplatecombitrans;
6818 delete endcapcoverplatetrans;
6819 for(Int_t i=0; i<3; i++){
6820 delete endcapsidecovercombitrans[i];
6821 if(i<2) delete endcapsidecoverot[i];
6822 }
6823 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6824 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6825 delete endcapcardsmatrix[0];
6826 return endcapassembly;
6827 }
6828 ////////////////////////////////////////////////////////////////////////////////
6829 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6830 Double_t radiusmax,
6831 Double_t width,
6832 Int_t ncables,
6833 char* volname){
6834 /////////////////////////////////////////////////////////////
6835 // Generating EndCap High Voltage Tubes
6836 /////////////////////////////////////////////////////////////
6837 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6838 Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.)
6839 + TMath::Power(radiusmax,2.)
6840 - TMath::Power(radiusmin,2.));
6841 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6842 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6843 effectiveouteradius,0.5*width);
6844 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6845 effectiveinnertubeshape,
6846 fSSDStiffenerConnectorMedium);
6847 effectiveinnertube->SetLineColor(41);
6848 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6849 effectiveoutertubeshape,
6850 fSSDKaptonChipCableMedium);
6851 effectiveoutertube->SetLineColor(39);
6852 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6853 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6854 effectivemothertube->AddNode(effectiveinnertube,1);
6855 effectivemothertube->AddNode(effectiveoutertube,1);
6856 return effectivemothertube;
6857 }
6858 ////////////////////////////////////////////////////////////////////////////////
6859 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6860 /////////////////////////////////////////////////////////////
6861 // Generating EndCap Support Layer 5 and Layer 6
6862 /////////////////////////////////////////////////////////////
6863 const Int_t knedges = 5;
6864 ///////////////////////////////////////////////
6865 // Setting the vertices for TGeoXtru Up Volume
6866 ///////////////////////////////////////////////
6867 const Int_t klayernumber = 2;
6868 Double_t xupvertex[klayernumber][knedges+3];
6869 Double_t yupvertex[klayernumber][knedges+3];
6870 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6871 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6872 Double_t middlepsi[klayernumber] = {0.0,0.0};
6873 for(Int_t i=0; i<klayernumber; i++){
6874 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6875 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6876 xupvertex[i][2] = -xupvertex[i][1];
6877 xupvertex[i][3] = -xupvertex[i][0];
6878
6879 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6880 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6881 yupvertex[i][2] = yupvertex[i][1];
6882 yupvertex[i][3] = yupvertex[i][0];
6883
6884 middledgeangle[i] = upedgeangle[i]/knedges;
6885 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6886 for(Int_t j=1; j<knedges; j++){
6887 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6888 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6889 }
6890 }
6891 ////////////////////////////////////
6892 // Generating Up TGeoXtru
6893 ////////////////////////////////////
6894 TGeoXtru* upendcapsupportshape[klayernumber];
6895 TGeoVolume* upendcapsupport[klayernumber];
6896 char upendcapsupportname[30];
6897 for(Int_t i=0; i<klayernumber; i++){
6898 upendcapsupportshape[i] = new TGeoXtru(2);
6899 sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6900 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6901 upendcapsupportshape[i]->DefineSection(0,0.);
6902 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6903 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 6904 fSSDSupportRingAl);
9b0c60ab 6905 upendcapsupport[i]->SetLineColor(5);
6906 }
6907 ///////////////////////////////////////////////
6908 // Setting the vertices for TGeoXtru Down Volume
6909 ///////////////////////////////////////////////
6910 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6911 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6912 for(Int_t i=0; i<klayernumber; i++){
6913 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6914 xdownvertex[i][1] = xupvertex[i][0];
6915 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6916 ydownvertex[i][1] = yupvertex[i][0];
6917 for(Int_t j=0; j<knedges; j++){
6918 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6919 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6920 }
6921 for(Int_t j=0; j<knedges; j++){
6922 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6923 * CosD(middlepsi[i]+j*middledgeangle[i]);
6924 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6925 * SinD(middlepsi[i]+j*middledgeangle[i]);
6926 }
6927 }
6928 ////////////////////////////////////
6929 // Generating Down TGeoXtru
6930 ////////////////////////////////////
6931 TGeoXtru* downendcapsupportshape[klayernumber];
6932 TGeoVolume* downendcapsupport[klayernumber];
6933 char downendcapsupportname[30];
6934 for(Int_t i=0; i<klayernumber; i++){
6935 downendcapsupportshape[i] = new TGeoXtru(2);
6936 sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
6937 downendcapsupportshape[i] = new TGeoXtru(2);
6938 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6939 if(i==0){
6940 downendcapsupportshape[i]->DefineSection(0,0.);
6941 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6942 }
6943 else{
6944 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6945 - fgkEndCapSupportLowWidth[i]);
6946 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6947 }
6948 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 6949 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 6950 downendcapsupport[i]->SetLineColor(5);
6951 }
6952 ///////////////////////////////////////////////
6953 // Setting TGeoPgon Volume
6954 ///////////////////////////////////////////////
6955 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6956 fgkSSDLay6LadderNumber};
6957 TGeoPgon* endcapsupportmothershape[klayernumber];
6958 TGeoVolume** endcapsupportmother;
6959 endcapsupportmother = new TGeoVolume*[klayernumber];
6960 char endcapsupportmothername[30];
6961 for(Int_t i=0; i<klayernumber; i++){
6962 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6963 sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
6964 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6965 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6966 ydownvertex[i][0],yupvertex[i][1]);
6967 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 6968 fSSDAir);
9b0c60ab 6969 }
6970 ////////////////////////////////////
6971 TGeoRotation** endcapsupportrot[klayernumber];
6972 for(Int_t i=0; i<2; i++){
6973 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6974 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6975 endcapsupportrot[i][j] = new TGeoRotation();
6976 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6977 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6978 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6979 }
6980 }
6981 return endcapsupportmother;
6982 }
6983 ////////////////////////////////////////////////////////////////////////////////
6984 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6985 /////////////////////////////////////////////////////////////
6986 // Setting End Cap Support Layer 5 and 6.
6987 /////////////////////////////////////////////////////////////
6988 const Int_t kendcapcoverplatesmallholenumber = 9;
6989 const Int_t klayernumber = 2;
6990 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6991 fgkSSDLay6LadderNumber};
6992 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6993 360.0/kssdlayladdernumber[1]};
6994 TGeoVolume** endcapsupport = EndCapSupport();
6995 TGeoVolume** endcapassembly = GetEndCapAssembly();
6996 TGeoPgon* endcapsupportshape[klayernumber];
6997 Double_t* radiusmin[klayernumber];
6998 Double_t* radiusmax[klayernumber];
6999 for(Int_t i=0; i<klayernumber; i++){
7000 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
7001 radiusmin[i] = endcapsupportshape[i]->GetRmin();
7002 radiusmax[i] = endcapsupportshape[i]->GetRmax();
7003 }
7004 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
7005 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
7006 endcapassemblyshape->GetDY(),
7007 endcapassemblyshape->GetDZ()};
7008 ///////////////////////////////////////////////
7009 // Setting TGeoPgon Volume for Mother Container
7010 ///////////////////////////////////////////////
7011 TGeoPgon* endcapsupportsystemshape[klayernumber];
7012 char endcapsupportsystemothername[30];
7013 for(Int_t i=0; i<klayernumber; i++){
7014 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7015 sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
7016 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
7017 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
7018 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7019 +2.*endcapassemblycenter[2])
7020 /CosD(0.5*upedgeangle[i]));
7021 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7022 -(fgkEndCapCoverPlateWidth[1]
7023 - fgkEndCapCoverPlateWidth[0]),
7024 *radiusmin[i],
7025 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7026 +2.*endcapassemblycenter[2])
7027 /CosD(0.5*upedgeangle[i]));
7028 }
e5bf64ae 7029 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 7030 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7031 endcapsupportsystemshape[0],fSSDAir);
7032 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7033 endcapsupportsystemshape[0],fSSDAir);
7034 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7035 endcapsupportsystemshape[1],fSSDAir);
7036 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7037 endcapsupportsystemshape[1],fSSDAir);
7038 ///////////////////////////////////////////////
7039 TGeoTranslation* endcapassemblytrans[klayernumber];
7040 for(Int_t i=0; i<klayernumber; i++)
7041 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7042 - fgkEndCapSideCoverThickness
7043 + endcapassemblycenter[0],
7044 - 0.5*fgkEndCapCoverPlateThickness
7045 - 2.0*fgkEndCapCoolingTubeRadiusMax
7046 + 2.0*endcapassemblycenter[2]
7047 + 0.5*fgkEndCapSupportLength[i]
7048 / TanD(0.5*upedgeangle[i]),
7049 0.5*(fgkEndCapCoverPlateWidth[0]
7050 - fgkEndCapCoverPlateWidth[2]
7051 - (kendcapcoverplatesmallholenumber-1)
7052 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
7053 TGeoRotation** endcapassemblyrot[klayernumber];
7054 TGeoHMatrix** endcapassemblymatrix[klayernumber];
7055 for(Int_t i=0; i<klayernumber; i++){
7056 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7057 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7058 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7059 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7060 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7061 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7062 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7063 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7064 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7065 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7066 }
7067 }
7068 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7069 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7070 for(Int_t i=0; i<2*klayernumber; i++){
7071 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7072 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7073 endcapassemblymatrix[1][j+2]);
7074 }
7075 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7076 }
7077 /////////////////////////////////////////////////////////////
7078 // Deallocating memory
7079 /////////////////////////////////////////////////////////////
7080 for(Int_t i=0; i<klayernumber; i++){
7081 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7082 delete endcapassemblyrot[i][j];
7083 }
7084 delete endcapassemblyrot[i];
7085 delete endcapassemblymatrix[i][0];
7086 delete endcapassemblymatrix[i][1];
7087 }
7088 /////////////////////////////////////////////////////////////
7089 }
7090 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7091 /////////////////////////////////////////////////////////////
7092 // Setting End Cap Support + End Cap Assembly of Layer 5.
7093 /////////////////////////////////////////////////////////////
7094 if (! moth) {
7095 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, mother is null!\n");
7096 return;
7097 };
e5bf64ae 7098 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7099 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7100 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7101 fgkEndCapSupportCenterLay5ITSPosition
7102 + fgkEndCapSupportCenterLay5Position
7103 - fgkEndCapSideCoverLength[2]);
7104 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7105 fgkEndCapSideCoverLength[2]
7106 - fgkEndCapSupportCenterLay5Position
7107 - fgkEndCapSupportCenterLay5ITSPosition);
7108 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7109 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7110 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7111 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7112 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7113 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7114 /////////////////////////////////////////////////////////////
7115 // Deallocating memory
7116 /////////////////////////////////////////////////////////////
7117 delete endcapsupportsystemrot;
7118 delete endcapsupportsystemITSCentertrans[1];
7119 }
7120 /////////////////////////////////////////////////////////////
7121 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7122 /////////////////////////////////////////////////////////////
7123 // Setting End Cap Support + End Cap Assembly of Layer 6.
7124 /////////////////////////////////////////////////////////////
7125 if (! moth) {
7126 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
7127 return;
7128 };
e5bf64ae 7129 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7130 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7131 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7132 fgkEndCapSupportCenterLay6ITSPosition
7133 + fgkEndCapSupportCenterLay6Position
7134 - fgkEndCapSideCoverLength[2]);
7135 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7136 fgkEndCapSideCoverLength[2]
7137 - fgkEndCapSupportCenterLay6Position
7138 - fgkEndCapSupportCenterLay6ITSPosition);
7139 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7140 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7141 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7142 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7143 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7144 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7145 /////////////////////////////////////////////////////////////
7146 // Deallocating memory
7147 /////////////////////////////////////////////////////////////
7148 delete endcapsupportsystemrot;
7149 delete endcapsupportsystemITSCentertrans[1];
7150 }
7151 ////////////////////////////////////////////////////////////////////////////////
7152 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7153 /////////////////////////////////////////////////////////////
7154 // Setting Ladder Support of Layer 5.
7155 /////////////////////////////////////////////////////////////
7156 if (! moth) {
7157 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
7158 return;
7159 };
7160 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7161 fMotherVol = moth;
7162 TGeoTranslation* centerITSRingSupportLay5trans[2];
7163 for(Int_t i=0; i<2; i++){
7164 centerITSRingSupportLay5trans[i] =
7165 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7166 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7167 }
7168 }
7169 ////////////////////////////////////////////////////////////////////////////////
7170 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7171 /////////////////////////////////////////////////////////////
7172 // Setting Ladder Support of Layer 6.
7173 /////////////////////////////////////////////////////////////
7174 if (! moth) {
7175 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
7176 return;
7177 };
7178 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7179 fMotherVol = moth;
7180 TGeoTranslation* centerITSRingSupportLay6trans[2];
7181 for(Int_t i=0; i<2; i++){
7182 centerITSRingSupportLay6trans[i] =
7183 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7184 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7185 }
7186 }
7187 ////////////////////////////////////////////////////////////////////////////////
d7599219 7188TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
44285dfa 7189 Double_t height, char* shapename, Int_t isign) const{
7190 /////////////////////////////////////////////////////////////
7191 // Method generating an Arb shape
7192 /////////////////////////////////////////////////////////////
7193 const Int_t kvertexnumber = 8;
7194 const Int_t ktransvectnumber = 2;
7195 TVector3* vertex[kvertexnumber];
7196 TVector3* transvector[2];
7197 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
7198 /////////////////////////////////////////////////////////////
d7599219 7199 //Setting the vertices for TGeoArb8
44285dfa 7200 /////////////////////////////////////////////////////////////
7201 vertex[0] = new TVector3(*vertexpos[0]);
7202 vertex[1] = new TVector3(*vertexpos[1]);
7203 vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
7204 vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
7205 vertex[4] = new TVector3(*vertexpos[2]);
7206 vertex[5] = new TVector3(*vertexpos[3]);
7207 vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
7208 vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
7209 /////////////////////////////////////////////////////////////
7210 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
7211 for(Int_t i = 0; i<kvertexnumber;i++)
7212 arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
bf210566 7213 /////////////////////////////////////////////////////////////
7214 // Deallocating memory
7215 /////////////////////////////////////////////////////////////
7216 for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
7217 for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
7218 /////////////////////////////////////////////////////////////
44285dfa 7219 return arbshape;
d7599219 7220}
bf210566 7221///////////////////////////////////////////////////////////////////////////////
7222TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
7223 Double_t rmax, Int_t nedges, Double_t height){
7224 /////////////////////////////////////////////////////////////
7225 // Method generating Arc shape
7226 /////////////////////////////////////////////////////////////
7227 const Int_t kvertexnumber = 2*nedges+2;
7228 TGeoXtru* arcshape = new TGeoXtru(2);
7229 TVector3** vertexposition[2];
7230 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
7231 Double_t angle = 0.;
7232 for(Int_t i=0; i<nedges+1; i++){
7233 angle = 90.+0.5*phi-i*(phi/nedges);
7234 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
7235 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
7236 }
7237 Double_t *xvertexpoints = new Double_t[kvertexnumber];
7238 Double_t *yvertexpoints = new Double_t[kvertexnumber];
7239 for(Int_t i=0; i<kvertexnumber; i++){
7240 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
7241 yvertexpoints[i] = vertexposition[0][i]->Y();
7242 }
7243 else if(i>=1&&i<nedges+2)
7244 {
7245 xvertexpoints[i] = vertexposition[1][i-1]->X();
7246 yvertexpoints[i] = vertexposition[1][i-1]->Y();
7247 }
7248 else
7249 {
7250 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
7251 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
7252 }
7253 }
7254 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
7255 arcshape->DefineSection(0,-0.5*height);
7256 arcshape->DefineSection(1,0.5*height);
44285dfa 7257 /////////////////////////////////////////////////////////////
bf210566 7258 // Deallocating memory
44285dfa 7259 /////////////////////////////////////////////////////////////
bf210566 7260 for(Int_t i=0; i<2; i++){
7261 for(Int_t j=0; j<nedges+1; j++)
7262 delete vertexposition[i][j];
7263 delete [] vertexposition[i];
7264 }
7265 delete [] xvertexpoints;
7266 delete [] yvertexpoints;
7267 /////////////////////////////////////////////////////////////
7268 return arcshape;
d7599219 7269}
7270////////////////////////////////////////////////////////////////////////////////
9b0c60ab 7271TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
7272 ///////////////////////////////////////////////////////////////////////
7273 // Method Generating the Screw Shape
7274 // radius[0]: outer radius
7275 // radius[1]: inner radius
7276 // edgesnumber[0]: outer number of edges
7277 // edgesnumber[1]: inner number of edges
7278 // section[0]: lower section position
7279 // section[1]: higher section position
7280 ///////////////////////////////////////////////////////////////////////
7281 Double_t outradius = radius[0];
7282 Double_t inradius = radius[1];
7283 Int_t outvertexnumber = edgesnumber[0];
7284 Int_t invertexnumber = edgesnumber[1];
7285 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7286 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
7287 for(Int_t i=0; i<outvertexnumber+1; i++){
7288 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
7289 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
7290 }
7291 for(Int_t i=0; i<invertexnumber+1; i++){
7292 xscrewvertex[outvertexnumber+i+1] = inradius*CosD(90.-i*360./invertexnumber);
7293 yscrewvertex[outvertexnumber+i+1] = inradius*SinD(90.-i*360./invertexnumber);
7294 }
7295 TGeoXtru* screwshape = new TGeoXtru(2);
7296 screwshape->DefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex);
7297 screwshape->DefineSection(0,section[0]);
7298 screwshape->DefineSection(1,section[1]);
7299 delete [] xscrewvertex;
7300 delete [] yscrewvertex;
7301 return screwshape;
7302}
7303////////////////////////////////////////////////////////////////////////////////
7304TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
7305 ///////////////////////////////////////////////////////////////////////
7306 // Method Generating the Hole Shape
7307 // radius of the Hole
7308 // nedges: number of edges to approximate the circle
7309 ///////////////////////////////////////////////////////////////////////
7310 Int_t vertexnumber = nedges+6;
7311 Double_t* xholevertex = new Double_t[vertexnumber];
7312 Double_t* yholevertex = new Double_t[vertexnumber];
7313 xholevertex[0] = radius;
7314 xholevertex[1] = xholevertex[0];
7315 xholevertex[2] = -xholevertex[1];
7316 xholevertex[3] = xholevertex[2];
7317 xholevertex[4] = xholevertex[0];
7318 yholevertex[0] = 0.;
7319 yholevertex[1] = -radius;
7320 yholevertex[2] = yholevertex[1];
7321 yholevertex[3] = -yholevertex[1];
7322 yholevertex[4] = yholevertex[3];
7323 for(Int_t i=0; i<nedges+1; i++){
7324 xholevertex[i+5] = radius*CosD(i*360./nedges);
7325 yholevertex[i+5] = radius*SinD(i*360./nedges);
7326 }
7327 TGeoXtru* holeshape = new TGeoXtru(2);
7328 holeshape->DefinePolygon(vertexnumber,xholevertex,yholevertex);
7329 holeshape->DefineSection(0,section[0]);
7330 holeshape->DefineSection(1,section[1]);
7331 delete [] xholevertex;
7332 delete [] yholevertex;
7333 return holeshape;
7334}
7335////////////////////////////////////////////////////////////////////////////////
44285dfa 7336TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
7337 /////////////////////////////////////////////////////////////
7338 // Given an axis specified by param, it gives the reflection of the point
7339 // respect to the axis
7340 /////////////////////////////////////////////////////////////
7341 TVector3* n = new TVector3(param[0],param[1],param[2]);
7342 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
7343 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 7344 /////////////////////////////////////////////////////////////
7345 // Deallocating memory
7346 /////////////////////////////////////////////////////////////
7347 delete n;
7348 /////////////////////////////////////////////////////////////
44285dfa 7349 return reflectedvector;
d7599219 7350}
7351////////////////////////////////////////////////////////////////////////////////
bf210566 7352TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
d7599219 7353 Double_t dx,
7354 Double_t dy,
7355 Double_t dz) const{
44285dfa 7356 /////////////////////////////////////////////////////////////
d7599219 7357 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 7358 /////////////////////////////////////////////////////////////
bf210566 7359 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
7360 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 7361 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 7362 hmatrix->SetTranslation(newvect);
7363 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
7364 delete hmatrix;
7365 return matrix;
d7599219 7366}
7367////////////////////////////////////////////////////////////////////////////////
d7599219 7368TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 7369 /////////////////////////////////////////////////////////////
7370 // Method returning the Medium type
7371 /////////////////////////////////////////////////////////////
d7599219 7372 char ch[30];
7373 sprintf(ch, "ITS_%s",mediumName);
7374 TGeoMedium* medium = gGeoManager->GetMedium(ch);
7375 if (! medium)
7376 printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
7377 return medium;
7378}
7379////////////////////////////////////////////////////////////////////////////////
d7599219 7380void AliITSv11GeometrySSD::CreateMaterials(){
7381///////////////////////////////////
7382// This part has to be modified
7383///////////////////////////////////
7384 ///////////////////////////////////
7385 // Silicon for Sensor
7386 ///////////////////////////////////
bf210566 7387 fSSDSensorMedium = GetMedium("SI$");
d7599219 7388 ///////////////////////////////////
7389 // Silicon Mixture for Sensor
7390 ///////////////////////////////////
44285dfa 7391 fSSDChipMedium = GetMedium("SPD SI CHIP$");
7392 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 7393 ///////////////////////////////////
7394 // Stiffener Components Materials
7395 ///////////////////////////////////
bf210566 7396 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 7397 ///////////////////////////
7398 // Stiffener Connectors
7399 ///////////////////////////
bf210566 7400 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 7401 ////////////////////////////////
7402 // Stiffener 0603-1812 Capacitor
7403 ////////////////////////////////
bf210566 7404 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
7405 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
d7599219 7406 ///////////////////////////
7407 // Stiffener Hybrid Wire
7408 ///////////////////////////
bf210566 7409 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 7410 ///////////////////////////
7411 // Al for Cooling Block
7412 ///////////////////////////
bf210566 7413 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 7414 //////////////////////////////////////////////////////
7415 // Kapton and Al for Chip Cable Flex and Ladder Cables
7416 //////////////////////////////////////////////////////
bf210566 7417 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7418 fSSDAlTraceChipCableMedium = GetMedium("AL$");
7419 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
7420 fSSDAlTraceFlexMedium = GetMedium("AL$");
7421 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
7422 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 7423 /////////////////////////////////////////////////////////////////
7424 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
7425 //////////////////////////////////////////////////////////////////
44285dfa 7426 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 7427 /////////////////////////////////////////////////////////////////
7428 // G10 for Detector Leg, TubeHolder
7429 //////////////////////////////////////////////////////////////////
44285dfa 7430 fSSDTubeHolderMedium = GetMedium("G10FR4$");
7431 fSSDSensorSupportMedium = GetMedium("G10FR4$");
7432 fSSDMountingBlockMedium = GetMedium("G10FR4$");
7433 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 7434 /////////////////////////////////////////////////////////////////
7435 // Water and Phynox for Cooling Tube
7436 //////////////////////////////////////////////////////////////////
bf210566 7437 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 7438 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 7439 /////////////////////////////////////////////////////////////////////
9b0c60ab 7440 // Material for Support Rings
7441 /////////////////////////////////////////////////////////////////////
7442 fSSDSupportRingAl = GetMedium("AL$");
7443 /////////////////////////////////////////////////////////////////////
bf210566 7444 fSSDAir = GetMedium("SDD AIR$");
7445 fCreateMaterials = kTRUE;
d7599219 7446}
7447/////////////////////////////////////////////////////////////////////