]> 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
Correcting assertion logic.
[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"
47f8de53 37#include "TGeoPcon.h"
9b0c60ab 38#include "TRotation.h"
44285dfa 39#include "AliITSv11GeometrySSD.h"
d7599219 40/////////////////////////////////////////////////////////////////////////////////
bf210566 41// Names of the Sensitive Volumes of Layer 5 and Layer 6
42/////////////////////////////////////////////////////////////////////////////////
02d4acf9 43const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5";
44const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6";
bf210566 45/////////////////////////////////////////////////////////////////////////////////
d7599219 46//Parameters for SSD Geometry
47/////////////////////////////////////////////////////////////////////////////////
e21cdd03 48// Variable for Vertical Disalignement of Modules
49/////////////////////////////////////////////////////////////////////////////////
02d4acf9 50const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
e21cdd03 51/////////////////////////////////////////////////////////////////////////////////
d7599219 52// Layer5 (lengths are in mm and angles in degrees)
53/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 54const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
d7599219 55const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
56const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
9acf2ecc 57const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
58const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
59const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
d7599219 60/////////////////////////////////////////////////////////////////////////////////
61// Layer6 (lengths are in mm and angles in degrees)
62/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 63const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
d7599219 64const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
65const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
9acf2ecc 66const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
67const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
68const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
d7599219 69/////////////////////////////////////////////////////////////////////////////////
70// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
71/////////////////////////////////////////////////////////////////////////////////
72const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
9acf2ecc 73const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
74const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
75const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
76const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
bf210566 77const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
78const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
9acf2ecc 79const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
d7599219 80/////////////////////////////////////////////////////////////////////////////////
81// Stiffener (lengths are in mm and angles in degrees)
82/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 83const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
84const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
bf210566 85//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 3.315;
9acf2ecc 86const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm;
87const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
bf210566 88const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
9acf2ecc 89const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
90const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
91const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
92const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
bf210566 93const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 0.700*fgkmm; // multiplied by 0.5
9acf2ecc 94const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
95const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
bf210566 96const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] =
97 {44.32*fgkmm, 0.33*fgkmm};
98const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
99const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
100const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
d7599219 101const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight =
bf210566 102 0.25*fgkSSDStiffenerHeight;
103const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
104const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
d7599219 105/////////////////////////////////////////////////////////////////////////////////
106// Cooling Block (lengths are in mm and angles in degrees)
107/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 108const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
109const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
bf210566 110const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
111 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
d7599219 112const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
bf210566 113 {1.000*fgkmm, 0.120*fgkmm};
d7599219 114const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
bf210566 115 {1.900*fgkmm, 0.400*fgkmm};
d7599219 116const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
9acf2ecc 117 1.500*fgkmm;
d7599219 118const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
9acf2ecc 119 0.300*fgkmm;
d7599219 120/////////////////////////////////////////////////////////////////////////////////
121// SSD Sensor (lengths are in mm and angles in degrees)
122/////////////////////////////////////////////////////////////////////////////////
123const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
bf210566 124 "SSDSensorSensitiveVol";
9acf2ecc 125const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
126const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
127const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
d7599219 128const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
9acf2ecc 129 fgkSSDSensorLength-39.1*fgkmm;
bf210566 130const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
131const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
d7599219 132/////////////////////////////////////////////////////////////////////////////////
133// Flex (lengths are in mm and angles in degrees)
134/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 135const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
d7599219 136const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
bf210566 137 {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
138 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
139 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
140 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
141 - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
d7599219 142const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
bf210566 143 { 9.340*fgkmm, 5.380*fgkmm};
d7599219 144const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
bf210566 145 { 0.030*fgkmm, 0.020*fgkmm};
d7599219 146const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
9acf2ecc 147const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
148const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
d7599219 149const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
bf210566 150 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
d7599219 151const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
bf210566 152 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
d7599219 153/////////////////////////////////////////////////////////////////////////////////
154// SSD Ladder Cable (lengths are in mm and angles in degrees)
155/////////////////////////////////////////////////////////////////////////////////
bf210566 156const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
d7599219 157/////////////////////////////////////////////////////////////////////////////////
158// SSD Module (lengths are in mm and angles in degrees)
159/////////////////////////////////////////////////////////////////////////////////
160const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
bf210566 161 { 1.000*fgkmm, 3.900*fgkmm};
d7599219 162const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
9acf2ecc 163 45.600*fgkmm;
d7599219 164const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
9acf2ecc 165 5.075*fgkmm;
d7599219 166/////////////////////////////////////////////////////////////////////////////////
167// Sensor Support (lengths are in mm and angles in degrees)
168/////////////////////////////////////////////////////////////////////////////////
bf210566 169const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
170 5.800*fgkmm;
d7599219 171const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
bf210566 172 2.000*fgkmm;
d7599219 173const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
bf210566 174 { 4.620*fgkmm, 5.180*fgkmm};
175const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
176 { 0.450*fgkmm, 0.450*fgkmm};
177const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
178 = 0.5 * (fgkSSDModuleSensorSupportDistance
179 + fgkSSDSensorSideSupportThickness[0])
180 - fgkSSDSensorSideSupportLength;
d7599219 181const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
bf210566 182 5.250*fgkmm;
d7599219 183const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
bf210566 184 1.680*fgkmm;
185const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
186 = {fgkSSDSensorSideSupportHeight[0]
187 + fgkSSDSensorSideSupportThickness[0],
188 fgkSSDSensorSideSupportHeight[1]
189 + fgkSSDSensorSideSupportThickness[1]};
190const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
191 = {fgkSSDSensorSideSupportThickness[0],
192 fgkSSDSensorSideSupportThickness[1]};
d7599219 193const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
bf210566 194 19.000*fgkmm;
d7599219 195/////////////////////////////////////////////////////////////////////////////////
196// Chip Cables (lengths are in mm and angles in degrees)
197/////////////////////////////////////////////////////////////////////////////////
198const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
bf210566 199 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
d7599219 200const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
bf210566 201 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
202 - (fgkSSDSensorSideSupportHeight[1]
203 - fgkSSDSensorSideSupportHeight[0])
204 - fgkSSDCoolingBlockHoleCenter
205 - fgkSSDStiffenerHeight
206 - fgkSSDChipHeight-fgkSSDSensorHeight,
207 fgkSSDModuleCoolingBlockToSensor
208 - fgkSSDCoolingBlockHoleCenter
209 - fgkSSDStiffenerHeight
210 - fgkSSDChipHeight-fgkSSDSensorHeight};
d7599219 211const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
bf210566 212 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
d7599219 213/////////////////////////////////////////////////////////////////////////////////
214// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
215/////////////////////////////////////////////////////////////////////////////////
216const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
bf210566 217 3.820*fgkmm;
218//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
219// 3.780;
d7599219 220const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
bf210566 221 fgkSSDSensorLength-fgkSSDSensorOverlap;
d7599219 222const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
bf210566 223 { 0.86*fgkmm, 0.30*fgkmm};
d7599219 224const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
bf210566 225 { 30.00, 90.00};
d7599219 226const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
bf210566 227 1.78*fgkmm;
d7599219 228/////////////////////////////////////////////////////////////////////////////////
229//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
230/////////////////////////////////////////////////////////////////////////////////
bf210566 231const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
232 = fgkSSDModuleSensorSupportDistance
233 - 2. * fgkCarbonFiberJunctionToSensorSupport;
234const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
d7599219 235const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
bf210566 236 { 0.751*fgkmm, 0.482*fgkmm};
237const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
238 1.630*fgkmm;
239const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
240const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
241 = fgkCarbonFiberTriangleLength
242 - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
243 / TMath::Cos(fgkCarbonFiberTriangleAngle
244 * TMath::DegToRad());
245const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
246 = 0.5*(fgkCarbonFiberJunctionWidth
247 - fgkCarbonFiberSupportWidth)
248 - fgkCarbonFiberSupportTopEdgeDist[0]
249 - fgkCarbonFiberSupportWidth;
d7599219 250/////////////////////////////////////////////////////////////////////////////////
251// Carbon Fiber Lower Support Parameters (lengths are in mm)
252/////////////////////////////////////////////////////////////////////////////////
253const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
9acf2ecc 254 = 0.950*fgkmm;
d7599219 255const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
9acf2ecc 256 = 1.600*fgkmm;
d7599219 257const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
9acf2ecc 258 = 0.830*fgkmm;
d7599219 259const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
260 = 0.5*fgkCarbonFiberSupportWidth;
261const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
bf210566 262 = fgkCarbonFiberJunctionWidth
263 - 2. * (fgkCarbonFiberLowerSupportWidth
264 + fgkCarbonFiberLowerSupportVolumeSeparation);
d7599219 265const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
bf210566 266 = {fgkCarbonFiberLowerSupportWidth
267 + fgkCarbonFiberLowerSupportVolumeSeparation,
268 fgkCarbonFiberLowerSupportWidth
269 + fgkCarbonFiberLowerSupportVolumeSeparation
270 + fgkCarbonFiberLowerSupportTransverseWidth};
d7599219 271/////////////////////////////////////////////////////////////////////////////////
272// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
273/////////////////////////////////////////////////////////////////////////////////
274const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
bf210566 275 {0.5 * (fgkSSDLay5LadderLength
276 - fgkSSDLay5SensorsNumber
277 * fgkCarbonFiberJunctionWidth
278 - fgkCarbonFiberLowerSupportWidth),
279 0.5 * (fgkSSDLay5LadderLength
280 - fgkSSDLay5SensorsNumber
281 * fgkCarbonFiberJunctionWidth
282 + fgkCarbonFiberLowerSupportWidth)};
d7599219 283const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
bf210566 284 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
285 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
d7599219 286const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
bf210566 287 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
288 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
9b0c60ab 289const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
290 {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
d7599219 291/////////////////////////////////////////////////////////////////////////////////
292// Cooling Tube Support (lengths are in mm and angles in degrees)
293/////////////////////////////////////////////////////////////////////////////////
bf210566 294const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
d7599219 295const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
296 = fgkSSDCoolingBlockHoleRadius[0];
bf210566 297const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
298const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
299const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
d7599219 300const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
bf210566 301 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
302const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
303 11.70*fgkmm;
d7599219 304/////////////////////////////////////////////////////////////////////////////////
305// Cooling Tube (lengths are in mm and angles in degrees)
306/////////////////////////////////////////////////////////////////////////////////
bf210566 307const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
308const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm;
309const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
d7599219 310 fgkCarbonFiberJunctionWidth;
311const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
bf210566 312 fgkSSDModuleSensorSupportDistance
313 + fgkSSDCoolingBlockLength;
9b0c60ab 314const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
d7599219 315/////////////////////////////////////////////////////////////////////////////////
316// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
317/////////////////////////////////////////////////////////////////////////////////
318const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
bf210566 319 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
d7599219 320const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
bf210566 321 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
d7599219 322const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
bf210566 323 20.0*fgkmm;
d7599219 324const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
bf210566 325 40.0;
d7599219 326const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
327 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
328const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
bf210566 329 2.5*fgkmm;
d7599219 330const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
bf210566 331 { 56.0*fgkmm, 12.0*fgkmm};
d7599219 332const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
bf210566 333 { 5.0*fgkmm, 2.9*fgkmm};
d7599219 334const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
bf210566 335 1.0*fgkmm;
d7599219 336const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
bf210566 337 6.0*fgkmm;
d7599219 338const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth =
bf210566 339 4.0*fgkmm;
d7599219 340const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
bf210566 341 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
d7599219 342/////////////////////////////////////////////////////////////////////////////////
9b0c60ab 343// SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
344/////////////////////////////////////////////////////////////////////////////////
345const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
346const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
347const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
348const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
349const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
350/////////////////////////////////////////////////////////////////////////////////
351// SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
352/////////////////////////////////////////////////////////////////////////////////
353const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
354const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
355const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
356 - fgkSSDMountingBlockHeight[1]
357 + 0.5*fgkCoolingTubeSupportHeight
358 + fgkSSDModuleCoolingBlockToSensor
e21cdd03 359 + fgkSSDModuleVerticalDisalignment
9b0c60ab 360 - fgkMountingBlockSupportDownHeight,
361 fgkSSDLay6RadiusMin
362 - fgkSSDMountingBlockHeight[1]
363 + 0.5*fgkCoolingTubeSupportHeight
364 + fgkSSDModuleCoolingBlockToSensor
e21cdd03 365 + fgkSSDModuleVerticalDisalignment
9b0c60ab 366 - fgkMountingBlockSupportDownHeight};
367const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
368 - fgkSSDMountingBlockHeight[1]
369 + 0.5*fgkCoolingTubeSupportHeight
370 + fgkSSDModuleCoolingBlockToSensor
e21cdd03 371 + fgkSSDModuleVerticalDisalignment
9b0c60ab 372 - fgkMountingBlockSupportRadius[0],
373 fgkSSDLay6RadiusMax
374 - fgkSSDMountingBlockHeight[1]
375 + 0.5*fgkCoolingTubeSupportHeight
376 + fgkSSDModuleCoolingBlockToSensor
e21cdd03 377 + fgkSSDModuleVerticalDisalignment
9b0c60ab 378 - fgkMountingBlockSupportRadius[1]};
379const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
380const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
381const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
382/////////////////////////////////////////////////////////////////////////////////
383// SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
384/////////////////////////////////////////////////////////////////////////////////
385const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
386const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
387const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
388const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
389 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
390const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
391 {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
392const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
393 {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
394const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
395const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
396const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
397const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
398const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
399const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
400/////////////////////////////////////////////////////////////////////////////////
401// SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
402/////////////////////////////////////////////////////////////////////////////////
403const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
404const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
405const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
406/////////////////////////////////////////////////////////////////////////////////
407// SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
408/////////////////////////////////////////////////////////////////////////////////
409const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
410 {10.5*fgkmm,9.25*fgkmm};
411const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
412const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
413const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
414 {182.3,177.9,84.4,70.0,35.0};
415const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
416 {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
417const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
418/////////////////////////////////////////////////////////////////////////////////
419// SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
420/////////////////////////////////////////////////////////////////////////////////
421const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
422 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
423const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
424 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
425 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
426const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
427/////////////////////////////////////////////////////////////////////////////////
428// SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
429/////////////////////////////////////////////////////////////////////////////////
430const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
431 {62.0*fgkmm,21.87*fgkmm};
432const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
433 {47.1*fgkmm,0.35*fgkmm};
434const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
435 1.0*fgkmm;
436const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
437const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
438 {43.5*fgkmm, 0.70*fgkmm};
439const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
440 0.15*fgkmm;
441const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
442 19.0*fgkmm;
443const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
444 {4.80*fgkmm,1.1*fgkmm};
445const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
446 {3.3*fgkmm,1.10*fgkmm};
447const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
448 2.1*fgkmm;
449const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
450 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
451const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
452 {1.9*fgkmm,0.15*fgkmm};
453const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
454 19*fgkmm;
455const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
456 1.0*fgkmm;
457const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
458 3.6*fgkmm;
459const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
460 61.0*fgkmm;
461const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
462 5.97*fgkmm;
463const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
464const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
465 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
466 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
467const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
468 {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
469const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
470 1.0*fgkmm;
471const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
472 = 0.15*fgkmm;
473const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
474 20.0*fgkmm;
475const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
476const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
477const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
478const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
479const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
480/////////////////////////////////////////////////////////////////////////////////
481// SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
482/////////////////////////////////////////////////////////////////////////////////
483const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
484const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
47f8de53 485const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {375.0*fgkmm,435.0*fgkmm};
9b0c60ab 486const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
487const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
488const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
489const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
490const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
491const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
492/////////////////////////////////////////////////////////////////////////////////
47f8de53 493// SSD Cone Parameters (lengths are in mm and angles in degrees)
494/////////////////////////////////////////////////////////////////////////////////
495const Double_t AliITSv11GeometrySSD::fgkSSDLowerPConeRadius = 296.5*fgkmm;
496const Double_t AliITSv11GeometrySSD::fgkSSDPConeAngle = 39.0;
fcfbdd23 497const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {168.0*fgkmm,153.0*fgkmm};
47f8de53 498const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleRadius = 317.5*fgkmm;
499const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleLength = 20.*fgkmm;
500const Double_t AliITSv11GeometrySSD::fgkSSDConeMiddleRadius = 350.*fgkmm;
501const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleLength = 30.*fgkmm;
502const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleWidth = 40.*fgkmm;
503const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpRadius = 400.*fgkmm;
fcfbdd23 504const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 459.*fgkmm;
47f8de53 505const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMiddleRadius = 472.5*fgkmm;
506const Double_t AliITSv11GeometrySSD::fgkSSDPConeDownRadius = 282.0*fgkmm;
507const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidAngle = 42.0;
508const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidBasis = 200.0*fgkmm;
509const Double_t AliITSv11GeometrySSD::fgkSSDPConeExternalRadius = 492.5*fgkmm;
510const Double_t AliITSv11GeometrySSD::fgkSSDPConeRadiusWidth = 16.75*fgkmm;
fcfbdd23 511const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 168.0*fgkmm;
47f8de53 512const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportLength = 1020.*fgkmm;
513const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm;
514const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm;
515const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportLength = 60.0*fgkmm;
516const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportWidth = 2.5*fgkSSDCentralSupportWidth;
517/////////////////////////////////////////////////////////////////////////////////
518// SSD Cables Parameters (lengths are in mm and angles in degrees)
519/////////////////////////////////////////////////////////////////////////////////
520const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
521const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
522const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
523const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
524const Double_t AliITSv11GeometrySSD::fgkSSDCableAngle = 22.5;
525const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm; // to be fixed in order to reproduce material budget
526const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
527const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
528const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
529const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
530const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = 451.3*fgkmm;
531const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = 451.3*fgkmm;
532const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeigth = 87.5*fgkmm;
533const Double_t AliITSv11GeometrySSD::fgkSSDCableMaterialBudgetHeight = 20.0*fgkmm;
534//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = fgkSSDPConeExternalRadius;
535//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = fgkSSDPConeExternalRadius;
536/////////////////////////////////////////////////////////////////////////////////
44285dfa 537ClassImp(AliITSv11GeometrySSD)
538/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 539AliITSv11GeometrySSD::AliITSv11GeometrySSD():
540 AliITSv11Geometry(),
44285dfa 541 fSSDChipMedium(),
542 fSSDChipGlueMedium(),
543 fSSDStiffenerMedium(),
544 fSSDStiffenerConnectorMedium(),
545 fSSDStiffener0603CapacitorMedium(),
546 fSSDStiffener1812CapacitorMedium(),
547 fSSDStiffenerHybridWireMedium(),
548 fSSDKaptonFlexMedium(),
549 fSSDAlTraceFlexMedium(),
550 fSSDAlTraceLadderCableMedium(),
551 fSSDKaptonLadderCableMedium(),
552 fSSDKaptonChipCableMedium(),
553 fSSDAlTraceChipCableMedium(),
554 fSSDAlCoolBlockMedium(),
555 fSSDSensorMedium(),
556 fSSDSensorSupportMedium(),
557 fSSDCarbonFiberMedium(),
558 fSSDTubeHolderMedium(),
559 fSSDCoolingTubeWater(),
560 fSSDCoolingTubePhynox(),
9b0c60ab 561 fSSDSupportRingAl(),
44285dfa 562 fSSDMountingBlockMedium(),
47f8de53 563 fSSDRohaCellCone(),
bf210566 564 fSSDAir(),
47f8de53 565 fSSDCopper(),
bf210566 566 fCreateMaterials(kFALSE),
567 fTransformationMatrices(kFALSE),
568 fBasicObjects(kFALSE),
569 fcarbonfiberjunction(),
570 fcoolingtubesupport(),
571 fhybridmatrix(),
572 fssdcoolingblocksystem(),
573 fcoolingblocksystematrix(),
574 fssdstiffenerflex(),
575 fssdendflex(),
9b0c60ab 576 fendladdercoolingtubesupportmatrix(),
bf210566 577 fendladdermountingblock(),
9b0c60ab 578 fendladdermountingblockclip(),
bf210566 579 fSSDSensor5(),
580 fSSDSensor6(),
581 fSSDLayer5(),
582 fSSDLayer6(),
583 fMotherVol(),
9b0c60ab 584 fLay5LadderSupportRing(),
585 fLay6LadderSupportRing(),
e5bf64ae 586 fgkEndCapSupportSystem(),
47f8de53 587 fSSDCone(),
44285dfa 588 fColorCarbonFiber(4),
589 fColorRyton(5),
bf210566 590 fColorPhynox(14),
44285dfa 591 fColorSilicon(3),
bf210566 592 fColorAl(38),
44285dfa 593 fColorKapton(6),
594 fColorPolyhamide(5),
595 fColorStiffener(9),
bf210566 596 fColorEpoxy(30),
597 fColorWater(7),
598 fColorG10(41)
44285dfa 599{
600 ////////////////////////
601 // Standard constructor
602 ////////////////////////
44285dfa 603}
604/////////////////////////////////////////////////////////////////////////////////
605AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
9acf2ecc 606 AliITSv11Geometry(s.GetDebug()),
44285dfa 607 fSSDChipMedium(s.fSSDChipMedium),
608 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
609 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
610 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
611 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
612 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
613 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
614 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
615 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
616 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
617 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
618 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
619 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
620 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
621 fSSDSensorMedium(s.fSSDSensorMedium),
622 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
623 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
624 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
625 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
626 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
9b0c60ab 627 fSSDSupportRingAl(s.fSSDSupportRingAl),
44285dfa 628 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
47f8de53 629 fSSDRohaCellCone(s.fSSDRohaCellCone),
bf210566 630 fSSDAir(s.fSSDAir),
47f8de53 631 fSSDCopper(s.fSSDCopper),
bf210566 632 fCreateMaterials(s.fCreateMaterials),
633 fTransformationMatrices(s.fTransformationMatrices),
634 fBasicObjects(s.fBasicObjects),
635 fcarbonfiberjunction(s.fcarbonfiberjunction),
636 fcoolingtubesupport(s.fcoolingtubesupport),
637 fhybridmatrix(s.fhybridmatrix),
638 fssdcoolingblocksystem(s.fssdcoolingblocksystem),
639 fcoolingblocksystematrix(s.fcoolingblocksystematrix),
640 fssdstiffenerflex(s.fssdstiffenerflex),
641 fssdendflex(s.fssdendflex),
9b0c60ab 642 fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
bf210566 643 fendladdermountingblock(s.fendladdermountingblock),
9b0c60ab 644 fendladdermountingblockclip(s.fendladdermountingblockclip),
bf210566 645 fSSDSensor5(s.fSSDSensor5),
646 fSSDSensor6(s.fSSDSensor6),
647 fSSDLayer5(s.fSSDLayer5),
648 fSSDLayer6(s.fSSDLayer6),
44285dfa 649 fMotherVol(s.fMotherVol),
9b0c60ab 650 fLay5LadderSupportRing(s.fLay5LadderSupportRing),
651 fLay6LadderSupportRing(s.fLay6LadderSupportRing),
e5bf64ae 652 fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
47f8de53 653 fSSDCone(s.fSSDCone),
44285dfa 654 fColorCarbonFiber(s.fColorCarbonFiber),
655 fColorRyton(s.fColorRyton),
656 fColorPhynox(s.fColorPhynox),
657 fColorSilicon(s.fColorSilicon),
658 fColorAl(s.fColorAl),
659 fColorKapton(s.fColorKapton),
660 fColorPolyhamide(s.fColorPolyhamide),
661 fColorStiffener(s.fColorStiffener),
bf210566 662 fColorEpoxy(s.fColorEpoxy),
663 fColorWater(s.fColorWater),
664 fColorG10(s.fColorG10)
44285dfa 665{
666 ////////////////////////
667 // Copy Constructor
668 ////////////////////////
d7599219 669}
670/////////////////////////////////////////////////////////////////////////////////
44285dfa 671AliITSv11GeometrySSD& AliITSv11GeometrySSD::
672operator=(const AliITSv11GeometrySSD &s){
673 ////////////////////////
674 // Assignment operator
675 ////////////////////////
676 this->~AliITSv11GeometrySSD();
677 new(this) AliITSv11GeometrySSD(s);
678 return *this;
679/*
680 if(&s == this) return *this;
681 fMotherVol = s.fMotherVol;
682 return *this;
683 */
684}
bf210566 685///////////////////////////////////////////////////////////////////////////////
686void AliITSv11GeometrySSD::CreateTransformationMatrices(){
687 ///////////////////////////////////////////////////////////////////////
688 // Method generating the trasformation matrix for the whole SSD Geometry
689 ///////////////////////////////////////////////////////////////////////
690 // Setting some variables for Carbon Fiber Supportmatrix creation
691 //////////////////////////////////////////////////////////////////////
692 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
693 * CosD(fgkCarbonFiberJunctionAngle[0]);
694 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
695 + fgkCarbonFiberSupportTopEdgeDist[0]
696 + fgkCarbonFiberSupportWidth);
697 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
698 * TanD(fgkCarbonFiberJunctionAngle[0]);
699 TGeoRotation* carbonfiberot[3];
700 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
701 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
702 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
703 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
704 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
705 * CosD(fgkCarbonFiberTriangleAngle),0.,
706 - fgkCarbonFiberTriangleLength
707 * SinD(fgkCarbonFiberTriangleAngle)};
708 ///////////////////////////////////////////
709 //Setting Local Translations and Rotations:
710 ///////////////////////////////////////////
711 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
712 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
713 0.5*carbonfibersupportheight,NULL);
714 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
715 2.*symmetryplaneposition+transvector[1],
716 transvector[2], carbonfiberot[2]);
717 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
718 /////////////////////////////////////////////////////////////
719 // Carbon Fiber Support Transformations
720 /////////////////////////////////////////////////////////////
721 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
722 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
723 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
724 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
725 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
726 }
727 /////////////////////////////////////////////////////////////
728 // Carbon Fiber Junction Transformation
729 /////////////////////////////////////////////////////////////
730 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
731 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
732 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
733 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
734 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
735 localcarbonfiberjunctionmatrix[i] =
736 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
737 localcarbonfiberjunctionrot[i] =
738 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
739 localcarbonfiberjunctiontrans[i] =
740 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 741 }
bf210566 742 ///////////////////////
743 // Setting Translations
744 ///////////////////////
745 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
746 localcarbonfiberjunctiontrans[1][0] =
747 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
748 localcarbonfiberjunctiontrans[2][0] =
749 new TGeoTranslation(fgkCarbonFiberTriangleLength
750 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
751 fgkCarbonFiberTriangleLength
752 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
753 localcarbonfiberjunctiontrans[0][1] =
754 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
755 localcarbonfiberjunctiontrans[1][1] =
756 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
757 localcarbonfiberjunctiontrans[2][1] =
758 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
759 ////////////////////
760 // Setting Rotations
761 ////////////////////
762 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
763 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
764 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
765 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
766 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
767 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
768 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
769 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
770 ////////////////////////////////////////
771 // Setting Carbon Fiber Junction matrix
772 ////////////////////////////////////////
773 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
774 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
775 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
776 localcarbonfiberjunctionmatrix[i][j] =
777 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
778 *localcarbonfiberjunctionrot[i][j]);
779 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
780 }
d7599219 781 }
bf210566 782 /////////////////////////////////////////////////////////////
783 // Carbon Fiber Lower Support Transformations
784 /////////////////////////////////////////////////////////////
785 TGeoTranslation* localcarbonfiberlowersupportrans[2];
786 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
787 fgkCarbonFiberLowerSupportVolumePosition[1]
788 + fgkCarbonFiberLowerSupportVolumePosition[0],
789 0.0);
790 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
791 fgkCarbonFiberJunctionWidth
792 - fgkCarbonFiberLowerSupportWidth
793 - fgkCarbonFiberLowerSupportVolumePosition[0]
794 - fgkCarbonFiberLowerSupportVolumePosition[1],
795 - 0.5*fgkCarbonFiberLowerSupportHeight);
796 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
797 fcarbonfiberlowersupportrans[0] =
798 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
799 fcarbonfiberlowersupportrans[1] =
800 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
801 /////////////////////////////////////////////////////////////
802 // SSD Sensor Support Transformations
803 /////////////////////////////////////////////////////////////
804 const Int_t kssdsensorsupportmatrixnumber = 3;
805 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
806 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
807 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
808 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
809 localssdsensorsupportmatrix[i] =
810 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
811 localssdsensorsupportrot[i] =
812 new TGeoRotation*[kssdsensorsupportmatrixnumber];
813 localssdsensorsupportrans[i] =
814 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 815 }
bf210566 816 ///////////////////////
817 // Setting Translations
818 ///////////////////////
819 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
820 0.5*fgkSSDSensorSideSupportWidth,
821 0.0);
822 localssdsensorsupportrans[1][0] =
823 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
824 localssdsensorsupportrans[2][0] =
825 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
826 localssdsensorsupportrans[0][1] =
827 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
828 0.5*fgkSSDSensorSideSupportThickness[0],
829 0.0);
830 localssdsensorsupportrans[1][1] =
831 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
832 - 0.5*fgkSSDSensorSideSupportThickness[0]
833 - fgkSSDModuleSensorSupportDistance,
834 0.0);
835 localssdsensorsupportrans[2][1] =
836 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
837 - fgkSSDSensorCenterSupportPosition,
838 0.5*fgkSSDSensorCenterSupportWidth
839 - 0.5*fgkSSDModuleSensorSupportDistance,
840 fgkSSDSensorCenterSupportThickness[0]);
841 localssdsensorsupportrans[0][2] =
842 new TGeoTranslation(fgkCarbonFiberTriangleLength
843 + fgkCarbonFiberJunctionToSensorSupport,
844 fgkCarbonFiberJunctionWidth
845 - 0.5*(fgkCarbonFiberLowerSupportWidth
846 + fgkSSDSensorCenterSupportLength
847 - fgkSSDSensorCenterSupportThickness[0])
848 - fgkSSDSensorCenterSupportPosition,
849 0.0);
850 localssdsensorsupportrans[1][2] =
851 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
852 localssdsensorsupportrans[2][2] =
853 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
854 ////////////////////
855 // Setting Rotations
856 ////////////////////
857 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
858 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
859 localssdsensorsupportrot[i][j] = new TGeoRotation();
860 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
861 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
862 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 863 }
bf210566 864 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
865 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
866 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
867 ////////////////////////////////////////
868 // SSD Sensor Support matrix
869 ////////////////////////////////////////
870 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
871 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
872 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
873 localssdsensorsupportmatrix[i][j] =
874 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
875 *localssdsensorsupportrot[i][j]);
876 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
877 }
d7599219 878 }
44285dfa 879 /////////////////////////////////////////////////////////////
bf210566 880 // SSD Cooling Tube Support Transformations
44285dfa 881 /////////////////////////////////////////////////////////////
bf210566 882 const Int_t kcoolingtubesupportmatrixnumber = 2;
883 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
884 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
885 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 886 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 887 /fgkCoolingTubeSupportRmax);
bf210566 888 localcoolingtubesupportrans[0] =
889 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 890 + 2.*(fgkCoolingTubeSupportLength
44285dfa 891 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 892 + fgkCarbonFiberTriangleLength
bf210566 893 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
894 localcoolingtubesupportrans[1] =
895 new TGeoTranslation(fgkCarbonFiberJunctionLength
896 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
897 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
898 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
899 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
900 - 0.5*(fgkCarbonFiberLowerSupportWidth
901 + fgkSSDSensorCenterSupportLength
902 - fgkSSDSensorCenterSupportThickness[0])
903 + 0.5*fgkSSDSensorLength,
904 - 0.5*fgkCoolingTubeSupportHeight);
905 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
906 localcoolingtubesupportrot[i] = new TGeoRotation();
907 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
908 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
909 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
910 localcoolingtubesupportmatrix[i] =
911 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
912 *localcoolingtubesupportrot[i]);
913 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
914 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
915 (*localcoolingtubesupportmatrix[0]));
916 /////////////////////////////////////////////////////////////
9b0c60ab 917 // End Ladder SSD Cooling Tube Support Transformations
918 /////////////////////////////////////////////////////////////
919 TGeoTranslation** localendladdercooltubetrans[2];
920 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
921 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
922 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
923 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
924 - (fgkCoolingTubeSupportLength
925 - fgkCoolingTubeSupportRmax),
926 fgkEndLadderMountingBlockPosition[0]
927 - fgkendladdercoolingsupportdistance[0]
928 + 0.5*fgkCoolingTubeSupportWidth,
929 - 0.5*fgkCoolingTubeSupportHeight);
930 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
931 - (fgkCoolingTubeSupportLength
932 - fgkCoolingTubeSupportRmax),
933 fgkEndLadderMountingBlockPosition[0]
934 + fgkendladdercoolingsupportdistance[1]
935 + 0.5*fgkCoolingTubeSupportWidth,
936 - 0.5*fgkCoolingTubeSupportHeight);
937 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
938 - fgkCoolingTubeSupportRmax)
939 + fgkCarbonFiberTriangleLength
940 - 2.0*fgkCarbonFiberJunctionLength,
941 0.0,
942 0.0);
943 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
944 fgkendladdercoolingsupportdistance[0]
945 + fgkendladdercoolingsupportdistance[1],
946 0.0);
947 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
948 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
949 + fgkCarbonFiberJunctionLength
950 - fgkCoolingTubeSupportLength,
951 fgkEndLadderCarbonFiberLowerJunctionLength[1]
952 - 0.5*fgkCoolingTubeSupportWidth
953 -fgkendladdercoolingsupportdistance[2],
954 - 0.5*fgkCoolingTubeSupportHeight);
955 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
956 + fgkCoolingTubeSupportLength
957 - fgkCoolingTubeSupportRmax
958 - fgkCarbonFiberJunctionLength,
959 fgkEndLadderCarbonFiberLowerJunctionLength[1]
960 - 0.5*fgkCoolingTubeSupportWidth
961 - fgkendladdercoolingsupportdistance[2],
962 - 0.5*fgkCoolingTubeSupportHeight);
963 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
964 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
965 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
966 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
967 (*localcoolingtubesupportrot[1]));
968 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
969 (*localcoolingtubesupportrot[1]));
970 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
971 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
972 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
973 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
974 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
975
976 fendladdercoolingtubesupportmatrix[1][0] =
977 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
978 *(*localcoolingtubesupportrot[1]));
979 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
980 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
981 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
982 /////////////////////////////////////////////////////////////
bf210566 983 // SSD Cooling Tube Transformations
984 /////////////////////////////////////////////////////////////
985 TGeoRotation* localcoolingtuberot = new TGeoRotation();
986 localcoolingtuberot->SetAngles(0.,90.,0.);
987 TGeoTranslation** localcoolingtubetrans[4];
988 TVector3** localcoolingtubevect[4];
989 for(Int_t i=0; i<4; i++){
990 localcoolingtubevect[i] = new TVector3*[2];
991 localcoolingtubetrans[i] = new TGeoTranslation*[2];
992 fcoolingtubematrix[i] = new TGeoHMatrix*[2];
d7599219 993 }
bf210566 994 localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
995 -fgkCarbonFiberTriangleLength),
996 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
997 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
998 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
999 - 0.5*(fgkCarbonFiberLowerSupportWidth
1000 + fgkSSDSensorCenterSupportLength
1001 - fgkSSDSensorCenterSupportThickness[0])+
1002 0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
1003 - 2.0*fgkSSDModuleStiffenerPosition[1]
1004 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
1005 - 0.5*fgkCoolingTubeSupportWidth,
1006 - 0.5*fgkCoolingTubeSupportHeight);
1007 localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
1008 localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
1009 - 2.0*fgkSSDModuleStiffenerPosition[1]
1010 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
1011 + fgkCoolingTubeSupportWidth,
1012 localcoolingtubevect[0][0]->Z());
1013 localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
1014 + fgkCarbonFiberTriangleLength,
1015 localcoolingtubevect[0][0]->Y(),
1016 localcoolingtubevect[0][0]->Z());
1017 localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
1018 + fgkCarbonFiberTriangleLength,
1019 localcoolingtubevect[0][1]->Y(),
1020 localcoolingtubevect[0][1]->Z());
1021 localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
1022 - fgkCarbonFiberTriangleLength),
1023 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1024 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1025 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1026 - 0.5*(fgkCarbonFiberLowerSupportWidth
1027 + fgkSSDSensorCenterSupportLength
1028 - fgkSSDSensorCenterSupportThickness[0])
1029 + fgkSSDModuleStiffenerPosition[1]
1030 - 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
1031 - 0.5*fgkCoolingTubeSupportHeight);
1032 localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
1033 + fgkCarbonFiberTriangleLength,
1034 localcoolingtubevect[2][0]->Y(),
1035 localcoolingtubevect[2][0]->Z());
1036 localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
1037 - fgkCarbonFiberTriangleLength),
1038 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1039 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1040 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1041 - 0.5*(fgkCarbonFiberLowerSupportWidth
1042 + fgkSSDSensorCenterSupportLength
1043 - fgkSSDSensorCenterSupportThickness[0])
1044 + fgkSSDSensorLength
1045 - 0.5*fgkSSDModuleStiffenerPosition[1],
1046 - 0.5*fgkCoolingTubeSupportHeight);
1047 localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
1048 + fgkCarbonFiberTriangleLength,
1049 localcoolingtubevect[3][0]->Y(),
1050 - 0.5*fgkCoolingTubeSupportHeight);
1051 for(Int_t i=0; i<4; i++)
1052 for(Int_t j=0; j<2; j++){
1053 localcoolingtubetrans[i][j] =
1054 new TGeoTranslation(localcoolingtubevect[i][j]->X(),
1055 localcoolingtubevect[i][j]->Y(),
1056 localcoolingtubevect[i][j]->Z());
1057 fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
1058 * (*localcoolingtuberot));
1059 }
1060 /////////////////////////////////////////////////////////////
9b0c60ab 1061 // SSD End Ladder Cooling Tube Transformations
1062 /////////////////////////////////////////////////////////////
1063 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1064 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1065 TGeoTranslation** localendlladdercoolingtubetrans[2];
1066 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
1067 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
1068 for(Int_t i=0; i<2; i++)
1069 for(Int_t j=0; j<(i==0?6:4); j++)
1070 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1071 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1072 - fgkCoolingTubeSupportRmax)
1073 + fgkCarbonFiberJunctionLength,
1074 0.5*(fgkEndLadderMountingBlockPosition[0]
1075 - fgkendladdercoolingsupportdistance[0]),
1076 - 0.5*fgkCoolingTubeSupportHeight);
1077 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1078 - fgkCoolingTubeSupportRmax)
1079 - fgkCarbonFiberJunctionLength
1080 + fgkCarbonFiberTriangleLength,
1081 0.5*(fgkEndLadderMountingBlockPosition[0]
1082 - fgkendladdercoolingsupportdistance[0]),
1083 - 0.5*fgkCoolingTubeSupportHeight);
1084 localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1085 - fgkCoolingTubeSupportRmax)
1086 + fgkCarbonFiberJunctionLength,
1087 fgkEndLadderMountingBlockPosition[0]
1088 - fgkendladdercoolingsupportdistance[0]
1089 + 0.5*(fgkendladdercoolingsupportdistance[0]
1090 + fgkendladdercoolingsupportdistance[1]
1091 + fgkCoolingTubeSupportWidth),
1092 - 0.5*fgkCoolingTubeSupportHeight);
1093 localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
1094 - fgkCoolingTubeSupportRmax)
1095 - fgkCarbonFiberJunctionLength
1096 + fgkCarbonFiberTriangleLength,
1097 fgkEndLadderMountingBlockPosition[0]
1098 - fgkendladdercoolingsupportdistance[0]
1099 + 0.5*(fgkendladdercoolingsupportdistance[0]
1100 + fgkendladdercoolingsupportdistance[1]
1101 + fgkCoolingTubeSupportWidth),
1102 - 0.5*fgkCoolingTubeSupportHeight);
1103 localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
1104 - fgkCoolingTubeSupportRmax)
1105 + fgkCarbonFiberJunctionLength,
1106 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1107 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1108 - fgkEndLadderMountingBlockPosition[0]
1109 - fgkendladdercoolingsupportdistance[1]
1110 - fgkCoolingTubeSupportWidth),
1111 - 0.5*fgkCoolingTubeSupportHeight);
1112 localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
1113 - fgkCoolingTubeSupportRmax)
1114 - fgkCarbonFiberJunctionLength
1115 + fgkCarbonFiberTriangleLength,
1116 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1117 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1118 - fgkEndLadderMountingBlockPosition[0]
1119 - fgkendladdercoolingsupportdistance[1]
1120 - fgkCoolingTubeSupportWidth),
1121 - 0.5*fgkCoolingTubeSupportHeight);
1122 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1123 - fgkCoolingTubeSupportRmax)
1124 + fgkCarbonFiberJunctionLength,
1125 - 0.50 * (fgkMountingBlockToSensorSupport
1126 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1127 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1128 + fgkSSDSensorOverlap
1129 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1130 - fgkendladdercoolingsupportdistance[2]
1131 - fgkEndLadderMountingBlockPosition[1]
1132 - fgkCoolingTubeSupportWidth)
1133 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1134 - fgkendladdercoolingsupportdistance[2]
1135 - fgkCoolingTubeSupportWidth,
1136 - 0.5*fgkCoolingTubeSupportHeight);
1137 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1138 - fgkCoolingTubeSupportRmax)
1139 - fgkCarbonFiberJunctionLength
1140 + fgkCarbonFiberTriangleLength,
1141 - 0.50 * (fgkMountingBlockToSensorSupport
1142 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1143 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1144 + fgkSSDSensorOverlap
1145 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1146 - fgkendladdercoolingsupportdistance[2]
1147 - fgkEndLadderMountingBlockPosition[1]
1148 - fgkCoolingTubeSupportWidth)
1149 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1150 - fgkendladdercoolingsupportdistance[2]
1151 - fgkCoolingTubeSupportWidth,
1152 - 0.5*fgkCoolingTubeSupportHeight);
1153 localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1154 - fgkCoolingTubeSupportRmax)
1155 + fgkCarbonFiberJunctionLength,
1156 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1157 - 0.5*fgkendladdercoolingsupportdistance[2],
1158 - 0.5*fgkCoolingTubeSupportHeight);
1159 localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
1160 - fgkCoolingTubeSupportRmax)
1161 - fgkCarbonFiberJunctionLength
1162 + fgkCarbonFiberTriangleLength,
1163 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1164 - 0.5*fgkendladdercoolingsupportdistance[2],
1165 - 0.5*fgkCoolingTubeSupportHeight);
1166 fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
1167 fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
1168 for(Int_t i=0; i<2; i++)
1169 for(Int_t j=0; j<(i==0?6:4); j++){
1170 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1171 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1172 }
1173 /////////////////////////////////////////////////////////////
bf210566 1174 // SSD Hybrid Components Transformations
1175 /////////////////////////////////////////////////////////////
1176 const Int_t khybridmatrixnumber = 3;
1177 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1178 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1179 0.5*fgkSSDStiffenerWidth,
1180 0.5*fgkSSDStiffenerHeight);
1181 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1182 fgkSSDModuleStiffenerPosition[1],0.0);
1183
1184 localhybridtrans[2] = new TGeoTranslation(
1185 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1186 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1187 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1188 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1189 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1190 - fgkSSDSensorCenterSupportThickness[0]),
1191 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
1192 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight));
1193 fhybridmatrix = new TGeoHMatrix();
1194 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1195 /////////////////////////////////////////////////////////////
1196 // SSD Cooling Block Transformations
1197 /////////////////////////////////////////////////////////////
1198 const Int_t kcoolingblockmatrixnumber = 4;
1199 TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
1200 localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
1201 - fgkCoolingTubeSupportRmin),0.0,
1202 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1203 localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
1204 - 0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
1205 0.0,fgkSSDStiffenerHeight);
1206 localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
1207 localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
1208 fcoolingblocksystematrix = new TGeoHMatrix();
1209 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
1210 fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
1211 /////////////////////////////////////////////////////////////
1212 // SSD Stiffener Flex Transformations
1213 /////////////////////////////////////////////////////////////
1214 const Int_t klocalflexmatrixnumber = 4;
1215 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1216 for(Int_t i=0; i<fgkflexnumber; i++)
1217 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1218 for(Int_t i=0; i<fgkflexnumber; i++)
1219 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1220 localflexmatrix[i][j] = new TGeoCombiTrans();
1221 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1222 - 2.*fgkSSDModuleStiffenerPosition[1]
1223 - fgkSSDStiffenerWidth;
1224 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1225 +0.5*fgkSSDStiffenerLength,
1226 0.5*fgkSSDStiffenerWidth,
1227 -0.5*fgkSSDStiffenerHeight
1228 -0.5*fgkSSDFlexHeight[0]);
1229 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1230 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1231 -0.5*fgkSSDStiffenerWidth,
1232 -0.5*fgkSSDStiffenerHeight
1233 -0.5*fgkSSDFlexHeight[0]);
1234 TGeoRotation* localflexrot = new TGeoRotation();
1235 localflexrot->SetAngles(180.,0.,0.);
1236 localflexmatrix[1][0]->SetRotation(localflexrot);
1237 for(Int_t i=0; i<fgkflexnumber; i++)
1238 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1239 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1240 for(Int_t i=0; i<fgkflexnumber; i++){
1241 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1242 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1243 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1244 }
bf210566 1245 /////////////////////////////////////////////////////////////
1246 // SSD End Flex Transformations
1247 /////////////////////////////////////////////////////////////
1248 TGeoRotation* localendflexrot = new TGeoRotation();
1249 localendflexrot->SetAngles(0.0,90.0,0.0);
1250 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1251 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1252 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1253 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1254 * TMath::DegToRad()*ssdflexradiusmax
1255 - fgkSSDFlexLength[2]-TMath::Pi()
1256 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
1257 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1258 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1259 + fgkSSDFlexLength[2];
1260 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1261 0.5*fgkSSDFlexWidth[0],
1262 2.*fgkSSDStiffenerHeight
1263 + 0.5*fgkSSDFlexHeight[0]);
1264 localendflexmatrix->SetRotation(localendflexrot);
1265 for(Int_t i=0; i<fgkflexnumber; i++)
1266 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1267 /////////////////////////////////////////////////////////////
1268 // End Ladder Carbon Fiber Junction
1269 /////////////////////////////////////////////////////////////
1270 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1271 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1272 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1273 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1274 localendladdercarbonfiberjunctionmatrix[i]
1275 = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1276 localendladdercarbonfiberjunctionrot[i]
1277 = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1278 localendladdercarbonfiberjunctiontrans[i]
1279 = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1280 fendladdercarbonfiberjunctionmatrix[i]
1281 = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
d7599219 1282 }
bf210566 1283 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1284 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1285 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1286 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1287 }
1288 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1289 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1290 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1291 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1292 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1293 0.0,0.0);
1294 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1295 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1296 * SinD(fgkCarbonFiberTriangleAngle),
1297 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1298 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1299 }
1300 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1301 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1302 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1303 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1304 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1305 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1306 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1307 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1308 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1309 localendladdercarbonfiberjunctionglobalmatrix[i] =
1310 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1311 *localendladdercarbonfiberjunctionglobalrot[i]);
1312 }
1313 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1314 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1315 localendladdercarbonfiberjunctionmatrix[i][j] =
1316 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1317 *localendladdercarbonfiberjunctionrot[i][j]);
1318 fendladdercarbonfiberjunctionmatrix[i][j] =
1319 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1320 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1321 }
1322 /////////////////////////////////////////////////////////////
1323 // End Ladder Carbon Fiber Support
1324 /////////////////////////////////////////////////////////////
1325 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1326 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1327 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1328 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1329 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1330 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1331 }
1332 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1333 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1334 fendladdercarbonfibermatrix[i][j] =
1335 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1336 *(*fcarbonfibersupportmatrix[j]));
1337 /////////////////////////////////////////////////////////////
1338 // End Ladder SSD Mounting Block
1339 /////////////////////////////////////////////////////////////
1340 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1341 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1342 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1343 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1344 + fgkSSDMountingBlockLength[1])
1345 + 0.5*fgkCarbonFiberTriangleLength,
1346 fgkEndLadderMountingBlockPosition[i],
1347 - fgkSSDMountingBlockHeight[1]
1348 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1349 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1350 endladdermountingblockrot->SetAngles(0.,90.,0.);
1351 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1352 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1353 /////////////////////////////////////////////////////////////
1354 // End Ladder SSD Mounting Block Clip Matrix
1355 /////////////////////////////////////////////////////////////
1356 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1357 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1358
1359 TGeoRotation* localendladdercliprot = new TGeoRotation();
1360 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1361 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1362 - fgkSSDMountingBlockLength[1])
1363 + fgkSSDMountingBlockLength[0],0.,0.);
1364 localendladdercliprot->SetAngles(90.,180.,-90.);
1365 TGeoCombiTrans* localendladderclipcombitrans =
1366 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1367 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1368 for(Int_t j=0; j<2; j++){
1369 fendladdermountingblockclipmatrix[i][j] =
1370 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1371 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1372 }
bf210566 1373 /////////////////////////////////////////////////////////////
1374 // End Ladder Carbon Fiber Lower Support
1375 /////////////////////////////////////////////////////////////
1376 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1377 fendladderlowersupptrans[i] =
1378 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1379 + 0.5*fgkSSDMountingBlockWidth),
1380 - 0.5*fgkCarbonFiberLowerSupportHeight);
1381 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1382 fgkCarbonFiberLowerSupportVolumePosition[1]
1383 + fgkCarbonFiberLowerSupportVolumePosition[0],
1384 0.0);
1385 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1386 /////////////////////////////////////////////////////////////
1387 // Matrix for positioning Ladder into mother volume
1388 /////////////////////////////////////////////////////////////
1389 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1390 for(Int_t i=0; i<fgkladdernumber; i++)
1391 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1392 TGeoRotation* localladdermotherrot = new TGeoRotation();
1393 localladdermotherrot->SetAngles(0.,90.,0.);
1394 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1395 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1396 for(Int_t i=0; i<fgkladdernumber; i++){
1397 localladdermothertrans[i] = new TGeoTranslation(0.,
1398 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1399 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1400 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1401 * fgkCarbonFiberJunctionWidth,0.);
1402 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1403 *localladdermotherrot);
1404 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1405 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1406 }
44285dfa 1407 /////////////////////////////////////////////////////////////
bf210566 1408 // Ladder Cables Matrices
44285dfa 1409 /////////////////////////////////////////////////////////////
44285dfa 1410 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1411 + fgkSSDFlexHeight[1];
44285dfa 1412 Double_t ssdladdercabletransx[3];
1413 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1414 * SinD(2.*fgkSSDFlexAngle)
1415 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1416 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1417 - ssdladdercabletransx[0]
bf210566 1418 / SinD(2.*fgkSSDFlexAngle))
1419 * CosD(fgkSSDFlexAngle);
44285dfa 1420 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1421 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1422 - fgkSSDFlexLength[2]-TMath::Pi()
1423 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1424 - fgkSSDLadderCableWidth)
bf210566 1425 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1426 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1427 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1428 ssdladdercabletransx[1]
bf210566 1429 * TanD(fgkSSDFlexAngle),
44285dfa 1430 ssdladdercabletransx[2]
bf210566 1431 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1432 TGeoRotation* localladdercablerot[3];
bf210566 1433 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1434 localladdercablerot[0]->SetAngles(90.,0.,0.);
1435 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1436 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1437 * (*localladdercablerot[0]));
1438 ////////////////////////////////////////////
1439 // LocalLadderCableCombiTransMatrix
1440 ////////////////////////////////////////////
1441 const Int_t klocalladdersidecablesnumber = 2;
1442 const Int_t klocalladdercombitransnumber = 5;
1443 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1444 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1445 localladdercablecombitransmatrix[i] =
1446 new TGeoCombiTrans*[klocalladdercombitransnumber];
1447 ///////////////////////////////////////////
1448 // Left Side Ladder Cables Transformations
1449 ///////////////////////////////////////////
1450 localladdercablecombitransmatrix[0][0] =
d7599219 1451 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1452 0.,0.,NULL);
bf210566 1453 localladdercablecombitransmatrix[0][1] =
1454 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1455 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1456 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1457 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1458 - 0.5*(fgkCarbonFiberLowerSupportWidth
1459 + fgkSSDSensorCenterSupportLength
1460 - fgkSSDSensorCenterSupportThickness[0]),
1461 - (fgkSSDModuleCoolingBlockToSensor
1462 + 0.5*fgkCoolingTubeSupportHeight
1463 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1464 - fgkSSDChipHeight),NULL);
44285dfa 1465 localladdercablecombitransmatrix[0][2] =
d7599219 1466 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1467 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1468 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1469 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1470 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1471 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1472 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1473 new TGeoRotation("",180.,0.,0.));
44285dfa 1474 localladdercablecombitransmatrix[0][4] =
1475 new TGeoCombiTrans(-ssdladdercabletransx[0]
1476 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1477 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1478 0.,
1479 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1480 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1481 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1482 + ssdladdercabletransz[2],localladdercablerot[2]);
1483 ///////////////////////////////////////////
1484 // Rigth Side Ladder Cables Transformations
1485 ///////////////////////////////////////////
bf210566 1486 TGeoCombiTrans* localladdercablessdmodulematrix =
1487 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1488 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1489 fgkSSDStiffenerWidth,
1490 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1491 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1492 localladdercablecombitransmatrix[1][i] =
bf210566 1493 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1494 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1495 ///////////////////////////////////////////
bf210566 1496 // Setting LadderCableHMatrix
44285dfa 1497 ///////////////////////////////////////////
bf210566 1498 Int_t beamaxistrans[2][3];
1499 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1500 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1501 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1502 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1503 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1504 beamaxistrans[1][2] = beamaxistrans[1][0];
1505 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1506 TGeoRotation* laddercablerot = new TGeoRotation();
1507 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1508 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1509 Double_t* laddercabletransvector;
1510 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1511 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1512 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1513 }
1514 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1515 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1516 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1517 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1518 localladdercablehmatrix[i][j]->MultiplyLeft(
1519 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1520 }
1521 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1522 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1523 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1524 laddercabletransvector[1]
bf210566 1525 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1526 * fgkCarbonFiberJunctionWidth,
bf210566 1527 laddercabletransvector[2]);
1528 laddercablecombitrans->SetRotation(*laddercablerot);
1529 laddercablecombitrans->SetTranslation(*laddercabletrans);
1530 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1531 }
1532 fladdercablematrix[i][2] =
1533 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1534 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1535 fladdercablematrix[i][3] =
1536 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1537 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1538 }
1539 for(Int_t i=0; i<fgkladdercablesnumber; i++)
1540 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1541 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1542 ///////////////////////////////////////////
1543 // Setting Ladder HMatrix
1544 ///////////////////////////////////////////
1545 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1546 fgkSSDLay6SensorsNumber};
1547 for(Int_t i=0; i<fgkladdernumber; i++){
1548 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1549 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1550 fladdermatrix[i][j] = new TGeoHMatrix();
1551 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1552 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1553 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1554 }
1555 }
1556 ///////////////////////////////////////////
1557 // Setting SSD Sensor Matrix
1558 ///////////////////////////////////////////
1559 TGeoCombiTrans* localssdsensorcombitrans[2];
1560 TGeoRotation* localssdsensorrot = new TGeoRotation();
1561 localssdsensorrot->SetAngles(0.,90.,0.);
1562 TGeoTranslation* localssdsensortrans[2];
1563 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1564 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1565 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1566 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1567 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1568 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1569 - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1570 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
02d4acf9 1571 - fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment
e21cdd03 1572 + (fgkSSDSensorSideSupportHeight[1]
bf210566 1573 - fgkSSDSensorSideSupportHeight[0]));
1574 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
1575 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1576 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1577 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1578 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1579 - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength,
1580 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
02d4acf9 1581 -fgkSSDModuleCoolingBlockToSensor-0.5*fgkSSDModuleVerticalDisalignment);
bf210566 1582 for(Int_t i=0; i<2; i++)
1583 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1584 *localssdsensorrot);
1585 for(Int_t i=0; i<fgkladdernumber; i++){
1586 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1587 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1588 switch(i){
1589 case 0: //Ladder of Layer5
1590 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1591 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1592 *localssdsensorcombitrans[1])));
1593 break;
1594 case 1: //Ladder of Layer6
1595 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1596 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1597 *localssdsensorcombitrans[0])));
1598 break;
1599 }
1600 }
1601 }
1602 //////////////////////////
1603 // Setting SSD End Ladder
1604 //////////////////////////
1605 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1606 for(Int_t i=0; i<2; i++){
1607 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1608 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1609 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1610 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1611 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1612 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1613 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1614 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1615 }
1616 /////////////////////////////////////////////////////
1617 // Setting the CombiTransformation to pass ITS center
1618 /////////////////////////////////////////////////////
1619 Double_t itscentertransz[fgklayernumber];
1620 itscentertransz[0] = fgkSSDLay5LadderLength
1621 - fgkLay5CenterITSPosition;
1622 itscentertransz[1] = fgkSSDLay6LadderLength
1623 - fgkLay6CenterITSPosition;
1624 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1625 + 0.5*fgkCoolingTubeSupportHeight;
1626 TGeoRotation* itscenterrot[3];
1627 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1628 itscenterrot[0]->SetAngles(90.,180.,-90.);
1629 itscenterrot[1]->SetAngles(0.,90.,0.);
1630 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1631 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1632 for(Int_t i=0; i<fgklayernumber; i++)
1633 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1634 itssensortransy,
1635 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1636 - itscentertransz[i],itscenterrot[2]);
1637 TGeoRotation** locallayerrot[fgklayernumber];
1638 TGeoTranslation** locallayertrans[fgklayernumber];
1639 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1640 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1641 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1642 - fgkLay5CenterITSPosition);
1643 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1644 - fgkLay6CenterITSPosition);
1645 const Int_t kssdlayladdernumber[fgklayernumber] =
1646 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1647 for(Int_t i=0; i<fgklayernumber; i++){
1648 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1649 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1650 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1651 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1652 }
1653 Double_t layerladderangleposition[fgklayernumber] =
1654 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1655 Double_t layerradius = 0.;
1656 for(Int_t i=0; i<fgklayernumber; i++){
1657 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1658 switch(i){
1659 case 0: //Ladder of Layer5
1660 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1661 break;
1662 case 1: //Ladder of Layer6
1663 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1664 break;
1665 }
1666 locallayerrot[i][j] = new TGeoRotation();
1667 locallayertrans[i][j] = new TGeoTranslation();
1668 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1669 locallayertrans[i][j]->SetTranslation(layerradius
1670 * CosD(90.0+j*layerladderangleposition[i]),
1671 layerradius
1672 * SinD(90.0+j*layerladderangleposition[i]),0.);
1673 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1674 *locallayerrot[i][j]);
1675 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1676 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1677 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1678 }
1679 }
44285dfa 1680 /////////////////////////////////////////////////////////////
bf210566 1681 // Deallocating memory
44285dfa 1682 /////////////////////////////////////////////////////////////
bf210566 1683 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1684 delete carbonfiberot[i];
1685 delete localcarbonfibersupportmatrix[i];
1686 }
1687 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1688 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1689 delete localcarbonfiberjunctionmatrix[i][j];
1690 delete localcarbonfiberjunctionrot[i][j];
1691 delete localcarbonfiberjunctiontrans[i][j];
1692 }
1693 delete [] localcarbonfiberjunctionmatrix[i];
1694 delete [] localcarbonfiberjunctionrot[i];
1695 delete [] localcarbonfiberjunctiontrans[i];
1696 }
1697 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1698 delete localcarbonfiberlowersupportrans[i];
1699 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1700 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1701 delete localssdsensorsupportmatrix[i][j];
1702 delete localssdsensorsupportrot[i][j];
1703 delete localssdsensorsupportrans[i][j];
1704 }
1705 delete [] localssdsensorsupportmatrix[i];
1706 delete [] localssdsensorsupportrot[i];
1707 delete [] localssdsensorsupportrans[i];
1708 }
1709 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1710 delete localcoolingtubesupportmatrix[i];
1711 delete localcoolingtubesupportrot[i];
1712 delete localcoolingtubesupportrans[i];
1713 }
1714 for(Int_t i=0; i<4; i++){
1715 for(Int_t j=0; j<2; j++){
1716 delete localcoolingtubevect[i][j];
1717 delete localcoolingtubetrans[i][j];
1718 }
1719 delete [] localcoolingtubevect[i];
1720 delete [] localcoolingtubetrans[i];
1721 }
9b0c60ab 1722 delete endladdermountingblockrot;
bf210566 1723 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1724 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
1725 for(Int_t i=0; i<fgkflexnumber; i++){
1726 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1727 delete localflexmatrix[i][j];
1728 delete [] localflexmatrix[i];
1729 }
9b0c60ab 1730 delete localendlladdercoolingtuberot;
1731 for(Int_t i=0; i<2; i++){
1732 for(Int_t j=0; j<(i==0?6:4); j++)
1733 delete localendlladdercoolingtubetrans[i][j];
1734 delete [] localendlladdercoolingtubetrans[i];
1735 }
1736
bf210566 1737 delete localflexrot;
1738 delete localendflexrot;
1739 delete localendflexmatrix;
1740 for(Int_t i=0; i<fgkladdernumber; i++){
1741 delete localladdermothertrans[i];
1742 delete localladdermothercombitrans[i];
1743 }
1744 delete localladdermotherrot;
1745 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1746 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1747 delete localendladdercarbonfiberjunctionmatrix[i][j];
1748 delete localendladdercarbonfiberjunctionrot[i][j];
1749 delete localendladdercarbonfiberjunctiontrans[i][j];
1750 }
1751 delete [] localendladdercarbonfiberjunctionmatrix[i];
1752 delete [] localendladdercarbonfiberjunctionrot[i];
1753 delete [] localendladdercarbonfiberjunctiontrans[i];
1754 delete localendladdercarbonfiberjunctionglobalrot[i];
1755 delete localendladdercarbonfiberjunctionglobaltrans[i];
1756 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1757 }
9b0c60ab 1758 for(Int_t i=0; i<2; i++){
1759 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1760 delete [] localendladdercooltubetrans[i];
1761 }
1762 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1763 delete localendladdercarbonfibertrans[i];
1764 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1765 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1766 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1767 delete localladdercablecombitransmatrix[i][j];
1768 delete []localladdercablecombitransmatrix[i];
1769 }
9b0c60ab 1770 delete localendladdercliprot;
1771 delete localendladdercliptrans;
bf210566 1772 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1773 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1774 delete localladdercablehmatrix[i][j];
1775 delete []localladdercablehmatrix[i];
1776 }
1777 delete laddercablerot;
1778 delete laddercabletrans;
1779 delete laddercablecombitrans;
1780 delete localladdercablessdmodulematrix;
1781 delete localssdsensorrot;
1782 for(Int_t i=0; i<2; i++){
1783 delete localssdsensortrans[i];
1784 delete localssdsensorcombitrans[i];
1785 }
1786 for(Int_t i=0; i<fgklayernumber; i++){
1787 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1788 delete locallayerrot[i][j];
1789 delete locallayertrans[i][j];
1790 delete locallayercombitrans[i][j];
1791 }
1792 delete [] locallayerrot[i];
1793 delete [] locallayertrans[i];
1794 delete [] locallayercombitrans[i];
1795 delete localbeamaxistrans[i];
1796 }
1797 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1798 for(Int_t i=0; i<fgkladdernumber; i++){
1799 for(Int_t j=0; j<fgkladdernumber; j++)
1800 delete ladderglobalmatrix[i][j];
1801 delete [] ladderglobalmatrix[i];
1802 }
1803 /////////////////////////////////////////////////////////////
1804 fTransformationMatrices = kTRUE;
d7599219 1805}
bf210566 1806///////////////////////////////////////////////////////////////////////////////
1807void AliITSv11GeometrySSD::CreateBasicObjects(){
1808 /////////////////////////////////////////////////////////////
1809 // Method generating the Objects of SSD Geometry
1810 /////////////////////////////////////////////////////////////
1811 // SSD Sensor
1812 ///////////////////////////////////
1813 SetSSDSensor();
1814 /////////////////////////////////////////////////////////////
1815 // Carbon Fiber Support
1816 /////////////////////////////////////////////////////////////
1817 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1818 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1819 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1820 /////////////////////////////////////////////////////////////
bf210566 1821 // Carbon Fiber Junction
44285dfa 1822 /////////////////////////////////////////////////////////////
bf210566 1823 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
1824 /////////////////////////////////////////////////////////////
1825 // Carbon Fiber Lower Support
1826 /////////////////////////////////////////////////////////////
1827 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1828 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1829 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1830 /////////////////////////////
1831 // SSD Sensor Support
1832 /////////////////////////////
1833 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1834 new TGeoVolume*[fgkssdsensorsupportnumber];
44285dfa 1835 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
bf210566 1836 fgkSSDSensorSideSupportThickness[1]};
1837 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1838 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1839 fgkSSDSensorSideSupportHeight[i],
1840 fgkSSDSensorSideSupportWidth,
1841 sidesupporthickness);
1842 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1843 fgkSSDSensorCenterSupportHeight[i],
1844 fgkSSDSensorCenterSupportWidth,
1845 sidesupporthickness);
1846 }
1847 /////////////////////////////////////////////////////////////
1848 // SSD Cooling Tube Support
1849 /////////////////////////////////////////////////////////////
1850 Int_t edgesnumber = 16;
1851 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1852 /////////////////////////////////////////////////////////////
1853 // SSD Hybrid
1854 /////////////////////////////////////////////////////////////
1855 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1856 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1857 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1858 /////////////////////////////////////////////////////////////
1859 // SSD Cooling Block System
1860 /////////////////////////////////////////////////////////////
1861 fssdcoolingblocksystem = GetCoolingBlockSystem();
1862 /////////////////////////////////////////////////////////////
1863 // SSD Cooling Tube
1864 /////////////////////////////////////////////////////////////
1865 TList* coolingtubelist = GetCoolingTubeList();
1866 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
1867 fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
9b0c60ab 1868 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
1869 fendladdercoolingtube[i] =
1870 (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
bf210566 1871 /////////////////////////////////////////////////////////////
1872 // SSD Flex
1873 /////////////////////////////////////////////////////////////
1874 fssdstiffenerflex = GetSSDStiffenerFlex();
1875 fssdendflex = GetSSDEndFlex();
1876 ///////////////////////////////////
1877 // End Ladder Carbon Fiber Junction
1878 ///////////////////////////////////
1879 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1880 fendladdercarbonfiberjunction[i] =
1881 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1882 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1883 fendladdercarbonfiberjunction[i][0] =
1884 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
1885 fendladdercarbonfiberjunction[i][1] =
1886 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
1887 }
1888 ///////////////////////////////////
1889 // End Ladder Mounting Block
1890 ///////////////////////////////////
1891 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1892 ///////////////////////////////////
1893 // End Ladder Mounting Block
1894 ///////////////////////////////////
1895 fendladdermountingblockclip = GetMountingBlockClip();
1896 ///////////////////////////////////
1897 // Ladder Support
1898 ///////////////////////////////////
1899 TList* laddersupportlist = GetMountingBlockSupport(20);
1900 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1901 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1902 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1903 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
bf210566 1904 /////////////////////////////////////////////////////////////
1905 // Deallocating memory
44285dfa 1906 /////////////////////////////////////////////////////////////
bf210566 1907 delete carbonfibersupportlist;
1908 delete carbonfiberlowersupportlist;
1909 delete ssdhybridcomponentslist;
9b0c60ab 1910 delete laddersupportlist;
44285dfa 1911 /////////////////////////////////////////////////////////////
bf210566 1912 fBasicObjects = kTRUE;
1913}
1914/////////////////////////////////////////////////////////////////////////////////
1915void AliITSv11GeometrySSD::SetSSDSensor(){
1916 ////////////////////////////////////////////////////////////////
1917 // Method generating SSD Sensors: it sets the private variables
1918 // fSSDSensor5, fSSDSensor6
1919 ////////////////////////////////////////////////////////////////
44285dfa 1920 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1921 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1922 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
44285dfa 1923 0.5*ssdsensitivewidth,
bf210566 1924 0.5*fgkSSDSensorHeight,
1925 0.5*ssdsensitivelength);
1926 TGeoVolume* ssdsensorsensitiveLay5 =
02d4acf9 1927 new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1928 TGeoVolume* ssdsensorsensitiveLay6 =
02d4acf9 1929 new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1930 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1931 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
44285dfa 1932 TGeoBBox* ssdsensorinsensitiveshape[2];
1933 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1934 0.5*fgkSSDSensorInsensitiveWidth,
bf210566 1935 0.5*fgkSSDSensorHeight,
1936 0.5*fgkSSDSensorLength);
44285dfa 1937 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
44285dfa 1938 0.5*ssdsensitivewidth,
bf210566 1939 0.5*fgkSSDSensorHeight,
1940 0.5*fgkSSDSensorInsensitiveWidth);
44285dfa 1941 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1942 "SSDSensorInsensitive2"};
44285dfa 1943 TGeoVolume* ssdsensorinsensitive[2];
1944 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1945 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1946 fSSDSensorMedium);
1947 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1948 }
bf210566 1949 /////////////////////////////////////////////////////////////
1950 // Virtual Volume containing SSD Sensor
1951 /////////////////////////////////////////////////////////////
1952 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1953 0.5*fgkSSDSensorWidth,
1954 0.5*fgkSSDSensorHeight,
1955 0.5*fgkSSDSensorLength);
ef9451a3 1956 fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
bf210566 1957 fSSDAir);
ef9451a3 1958 fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
bf210566 1959 fSSDAir);
1960 /////////////////////////////////////////////////////////////
1961 for(Int_t i=0; i<4; i++){
1962 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1963 ssdsensorinsensitive[1],i<2?1:2,
1964 new TGeoTranslation(
1965 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1966 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1967 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1968 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1969 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
44285dfa 1970 ssdsensorinsensitive[1],i<2?1:2,
bf210566 1971 new TGeoTranslation(
1972 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1973 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1974 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1975 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1976 }
1977 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1978 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1979}
bf210566 1980///////////////////////////////////////////////////////////////////////////////
1981TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1982 /////////////////////////////////////////////////////////////
1983 // Method generating the Carbon Fiber Support
1984 /////////////////////////////////////////////////////////////
1985 const Int_t kvertexnumber = 4;
1986 const Int_t kshapesnumber = 2;
1987 TVector3** vertexposition[kshapesnumber];
1988 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1989 Double_t carbonfibersupportxaxisEdgeproj =
1990 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1991 * TMath::DegToRad());
1992 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1993 / fgkCarbonFiberSupportXAxisLength);
1994 /////////////////////
1995 //Vertex Positioning
1996 ////////////////////
1997 vertexposition[0][0] = new TVector3();
1998 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1999 fgkCarbonFiberSupportYAxisLength);
2000 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
2001 carbonfibersupportxaxisEdgeproj
2002 * TMath::Tan(theta));
2003 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
2004 - carbonfibersupportxaxisEdgeproj,
2005 fgkCarbonFiberSupportYAxisLength
2006 - vertexposition[0][2]->Y());
2007 ////////////////////////////////////////////////////
2008 //Setting the parameters for Isometry Transformation
2009 ////////////////////////////////////////////////////
2010 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
2011 + fgkCarbonFiberSupportTopEdgeDist[0]
2012 + fgkCarbonFiberSupportWidth);
2013 Double_t* param = new Double_t[4];
2014 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
2015 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
2016 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
2017 (GetReflection(vertexposition[0][j],param))->Y());
2018 char* carbonfibersupportshapename[kshapesnumber] =
2019 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
2020 char* carbonfibersupportname[kshapesnumber] =
2021 {"CarbonFiberSupport1","CarbonFiberSupport2"};
2022 TGeoArb8* carbonfibersupportshape[kshapesnumber];
2023 TGeoVolume* carbonfibersupport[kshapesnumber];
2024 TList* carbonfibersupportlist = new TList();
2025 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
2026 Double_t carbonfibersupportheight =
2027 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
2028 *TMath::DegToRad());
2029 for(Int_t i = 0; i< kshapesnumber; i++){
2030 carbonfibersupportshape[i] =
2031 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
2032 carbonfibersupportshapename[i],i==0 ? 1: -1);
2033 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
2034 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
2035 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
2036 carbonfibersupportlist->Add(carbonfibersupport[i]);
2037 }
2038 /////////////////////////////////////////////////////////////
2039 // Deallocating memory
2040 /////////////////////////////////////////////////////////////
2041 for(Int_t i=0; i< kshapesnumber; i++){
2042 for(Int_t j=0; j< kvertexnumber; j++)
2043 delete vertexposition[i][j];
2044 delete [] vertexposition[i];
2045 }
2046 delete [] param;
44285dfa 2047 /////////////////////////////////////////////////////////////
bf210566 2048 return carbonfibersupportlist;
d7599219 2049}
2050/////////////////////////////////////////////////////////////////////////////////
bf210566 2051TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 2052 /////////////////////////////////////////////////////////////
bf210566 2053 // Method generating SSD Carbon Fiber Junction
44285dfa 2054 /////////////////////////////////////////////////////////////
bf210566 2055 const Int_t kvertexnumber = 6;
2056 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
2057 Double_t reflectionparam[3] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
2058 * TMath::DegToRad()),-1.,0.};
2059 TVector3* vertex[kvertexnumber];
2060 vertex[0] = new TVector3();
2061 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2062 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2063 * TMath::DegToRad()),
2064 fgkCarbonFiberJunctionEdge[0]
2065 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
2066 * TMath::DegToRad()));
2067 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
2068 fgkCarbonFiberJunctionEdge[1]);
2069 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
2070 vertex[1] = GetReflection(vertex[5],reflectionparam);
2071 vertex[2] = GetReflection(vertex[4],reflectionparam);
2072 Double_t xvertexpoints[6], yvertexpoints[6];
2073 for(Int_t i=0; i<kvertexnumber; i++)
2074 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
2075 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2076 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
2077 carbonfiberjunctionshape->DefineSection(1,0.5*width);
2078 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
2079 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
2080 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
2081 /////////////////////////////////////////////////////////////
2082 // Deallocating memory
2083 /////////////////////////////////////////////////////////////
2084 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
2085 /////////////////////////////////////////////////////////////
2086 return carbonfiberjunction;
2087}
2088////////////////////////////////////////////////////////////////////////////////
2089TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
2090 /////////////////////////////////////////////////////////////
2091 // Method generating the Carbon Fiber Lower Support
2092 /////////////////////////////////////////////////////////////
2093 const Int_t kvertexnumber = 4;
2094 const Int_t kshapesnumber = 2;
2095 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
2096 fgkCarbonFiberLowerSupportWidth};
2097 TVector3** vertexposition[kshapesnumber];
2098 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2099 new TVector3*[kvertexnumber];
2100 //First Shape Vertex Positioning
2101 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2102 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2103 - fgkCarbonFiberLowerSupportLowerLenght);
2104 vertexposition[0][2] = new TVector3();
2105 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2106 //Second Shape Vertex Positioning
2107 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2108 - fgkCarbonFiberLowerSupportVolumePosition[0])
2109 / fgkCarbonFiberTriangleLength);
2110 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2111 vertexposition[0][0]->X()*TMath::Tan(theta)
2112 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2113 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2114 vertexposition[0][1]->X()*TMath::Tan(theta)
2115 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2116 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2117 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2118 fgkCarbonFiberLowerSupportVolumePosition[1]);
2119 char* carbonfiberlowersupportshapename[kshapesnumber] =
2120 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
2121 char* carbonfiberlowersupportname[kshapesnumber] =
2122 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2123 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2124 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2125 TList* carbonfiberlowersupportlist = new TList();
2126 for(Int_t i = 0; i< kshapesnumber; i++){
2127 carbonfiberlowersupportshape[i] =
2128 GetArbShape(vertexposition[i],width,
2129 fgkCarbonFiberLowerSupportHeight,
2130 carbonfiberlowersupportshapename[i]);
2131 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2132 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2133 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2134 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2135 }
2136 /////////////////////////////////////////////////////////////
2137 // Deallocating memory
2138 /////////////////////////////////////////////////////////////
2139 for(Int_t i=0; i< kshapesnumber; i++){
2140 for(Int_t j=0; j< kvertexnumber; j++)
2141 delete vertexposition[i][j];
2142 delete [] vertexposition[i];
2143 }
2144 /////////////////////////////////////////////////////////////
2145 return carbonfiberlowersupportlist;
2146}
2147///////////////////////////////////////////////////////////////////////////////
2148TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2149 Double_t width, Double_t* thickness)const{
2150 /////////////////////////////////////////////////////////////
2151 // Method generating the Sensor Support
2152 /////////////////////////////////////////////////////////////
2153 const Int_t kvertexnumber = 6;
2154 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2155 TVector3* vertexposition[kvertexnumber];
2156 vertexposition[0] = new TVector3();
2157 vertexposition[1] = new TVector3(0.0,length);
2158 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2159 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2160 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2161 vertexposition[5] = new TVector3(vertexposition[4]->X());
2162 Double_t xvertexpoints[6], yvertexpoints[6];
2163 for(Int_t i=0; i<kvertexnumber; i++)
2164 xvertexpoints[i] = vertexposition[i]->X(),
2165 yvertexpoints[i] = vertexposition[i]->Y();
2166 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2167 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2168 ssdsensorsupportshape->DefineSection(1,0.5*width);
2169 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2170 ssdsensorsupportshape,fSSDSensorSupportMedium);
2171 /////////////////////////////////////////////////////////////
2172 // Deallocating memory
2173 /////////////////////////////////////////////////////////////
2174 for (Int_t i=0; i<kvertexnumber; i++)
2175 delete vertexposition[i];
2176 /////////////////////////////////////////////////////////////
2177 return ssdsensorsupport;
2178}
2179////////////////////////////////////////////////////////////////////////////////
2180TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2181 /////////////////////////////////////////////////////////////
2182 // Method generating the Cooling Tube Support
2183 /////////////////////////////////////////////////////////////
2184 if(nedges%2!=0) nedges--;
2185 const Int_t kvertexnumber = nedges+5;
2186 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2187 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2188 Double_t angle = 90.+phi;
2189 Double_t psi = 90.-phi;
2190 ///////////////////////////////////////
2191 // Vertex Positioning for TGeoXTru
2192 ///////////////////////////////////////
2193 TVector3** vertexposition = new TVector3*[kvertexnumber];
2194 vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
2195 fgkCoolingTubeSupportRmin*SinD(angle));
2196 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2197 fgkCoolingTubeSupportRmax*SinD(angle));
2198 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2199 fgkCoolingTubeSupportRmax);
2200 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2201 fgkCoolingTubeSupportRmax);
2202 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2203 vertexposition[1]->Y());
2204 for(Int_t i=0; i<nedges; i++)
2205 vertexposition[i+5] =
2206 new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
2207 fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
2208 ///////////////////////////////////////////////////////////////////////
2209 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2210 ///////////////////////////////////////////////////////////////////////
2211 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2212 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2213 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2214 for(Int_t i=0; i<kvertexnumber; i++){
2215 xvertexpoints[i] = vertexposition[i]->X();
2216 yvertexpoints[i] = vertexposition[i]->Y();
2217 }
2218 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2219 yvertexpoints);
2220 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2221 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2222 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2223 coolingtubesupportarcshape,
2224 fSSDTubeHolderMedium);
2225 coolingtubesupportarc->SetLineColor(fColorG10);
2226 //////////////////////////////////////////////////////////////////////////
2227 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2228 //////////////////////////////////////////////////////////////////////////
2229 TGeoTubeSeg* coolingtubesupportsegshape =
2230 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2231 fgkCoolingTubeSupportRmax,
2232 0.5*fgkCoolingTubeSupportWidth,
2233 phi,360-phi);
2234 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2235 coolingtubesupportsegshape,
2236 fSSDTubeHolderMedium);
2237 coolingtubesupportseg->SetLineColor(fColorG10);
2238 //////////////////////////////////////////////////////////////////////////
2239 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2240 //////////////////////////////////////////////////////////////////////////
2241 Double_t* boxorigin = new Double_t[3];
2242 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2243 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2244 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2245 0.5*fgkCoolingTubeSupportHeight,
2246 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2247 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2248 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2249 coolingtubesupportbox->SetLineColor(fColorG10);
2250 //////////////////////////////////////////////////////////////////////////
2251 // Cooling Tube for Cooling Tube Support
2252 //////////////////////////////////////////////////////////////////////////
2253 TGeoXtru* coolingtubearcshape[2];
2254 coolingtubearcshape[0] = new TGeoXtru(2);
2255 Double_t* xvert = new Double_t[nedges+2];
2256 Double_t* yvert = new Double_t[nedges+2];
2257 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2258 ////////////////////////////////////////
2259 // Positioning the vertices for TGeoXTru
2260 ////////////////////////////////////////
2261 xvert[0] = 0., yvert[0] = 0.;
2262 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2263 for(Int_t i=0; i< nedges; i++)
2264 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2265 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2266 ////////////////////////////////////////
2267 // Defining TGeoXTru PolyGone
2268 ////////////////////////////////////////
2269 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2270 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2271 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2272 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2273 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2274 TGeoVolume* coolingtubearc[2];
2275 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2276 coolingtubearcshape[0],fSSDCoolingTubeWater);
2277 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2278 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2279 coolingtubearc[0]->SetLineColor(fColorWater);
2280 coolingtubearc[1]->SetLineColor(fColorPhynox);
2281 ////////////////////////////////////////////
2282 // Defining TGeoTubeSeg Part of Cooling Tube
2283 ////////////////////////////////////////////
2284 TGeoTubeSeg* coolingtubesegshape[2];
2285 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2286 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2287 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2288 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2289 TGeoVolume* coolingtubeseg[2];
2290 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2291 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2292 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2293 coolingtubesegshape[1],fSSDCoolingTubeWater);
2294 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2295 coolingtubeseg[1]->SetLineColor(fColorWater);
2296 /////////////////////////////////////////////////////////////
2297 // Virtual Volume containing Cooling Tube Support
2298 /////////////////////////////////////////////////////////////
2299 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2300 const Int_t kvirtualvertexnumber = 8;
2301 TVector3* virtualvertex[kvirtualvertexnumber];
2302 ////////////////////////////////////////
2303 // Positioning the vertices for TGeoXTru
2304 ////////////////////////////////////////
2305 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2306 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2307 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2308 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2309 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2310 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2311 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2312 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2313 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2314 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2315 xmothervertex[i] = virtualvertex[i]->X(),
2316 ymothervertex[i] = virtualvertex[i]->Y();
2317 ////////////////////////////////////////
2318 // Defining TGeoXTru PolyGone
2319 ////////////////////////////////////////
2320 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2321 ymothervertex);
2322 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2323 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2324 TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2325 virtualCoolingTubeSupportShape,fSSDAir);
2326 ////////////////////////////////////////
2327 // Positioning Volumes in Virtual Volume
2328 ////////////////////////////////////////
2329 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2330 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2331 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2332 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2333 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2334 virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2335 virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2336 virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2337 virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2338 /////////////////////////////////////////////////////////////
2339 // Deallocating memory
2340 /////////////////////////////////////////////////////////////
2341 delete [] vertexposition;
2342 delete xvertexpoints;
2343 delete yvertexpoints;
2344 delete xvert;
2345 delete yvert;
2346 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2347 delete virtualvertex[i];
2348 /////////////////////////////////////////////////////////////
2349 return virtualcoolingtubesupport;
2350}
2351/////////////////////////////////////////////////////////////////////////////////
2352TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2353 /////////////////////////////////////////////////////////////
2354 // Method generating List containing SSD Hybrid Components
2355 /////////////////////////////////////////////////////////////
2356 TList* ssdhybridlist = new TList();
2357 const Int_t kssdstiffenernumber = 2;
2358 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2359 - 2.*fgkSSDModuleStiffenerPosition[1]
2360 - fgkSSDStiffenerWidth;
2361 Double_t ssdchipcablesradius[kssdstiffenernumber];
2362 for(Int_t i=0; i<kssdstiffenernumber; i++)
2363 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2364 - fgkSSDChipCablesHeight[0]
2365 - fgkSSDChipCablesHeight[1]);
2366 /////////////////////////////////////////////////////////////
2367 // Mother Volumes Containers
2368 /////////////////////////////////////////////////////////////
2369 const Int_t kmothernumber = 2;
2370 const Int_t kmothervertexnumber = 12;
2371 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2372 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2373 ///////////////////////
2374 // Setting the vertices
2375 ///////////////////////
2376 xmothervertex[0][0] = -0.5*fgkSSDStiffenerLength;
2377 xmothervertex[0][1] = xmothervertex[0][0];
2378 xmothervertex[0][2] = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
2379 xmothervertex[0][3] = xmothervertex[0][2];
2380 xmothervertex[0][4] = xmothervertex[0][0];
2381 xmothervertex[0][5] = xmothervertex[0][4];
2382 xmothervertex[0][6] = -xmothervertex[0][0];
2383 xmothervertex[0][7] = xmothervertex[0][6];
2384 xmothervertex[0][8] = -xmothervertex[0][2];
2385 xmothervertex[0][9] = xmothervertex[0][8];
2386 xmothervertex[0][10] = xmothervertex[0][7];
2387 xmothervertex[0][11] = xmothervertex[0][10];
2388 for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
2389 for(Int_t i = 0; i<kmothernumber; i++){
2390 ymothervertex[i][0] = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
2391 + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
2392 ymothervertex[i][1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
2393 ymothervertex[i][2] = ymothervertex[i][1];
2394 ymothervertex[i][3] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
2395 ymothervertex[i][4] = ymothervertex[i][3];
2396 ymothervertex[i][5] = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
2397 ymothervertex[i][6] = ymothervertex[i][5];
2398 ymothervertex[i][7] = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
2399 ymothervertex[i][8] = ymothervertex[i][7];
2400 ymothervertex[i][9] = 0.5*fgkSSDStiffenerWidth;
2401 ymothervertex[i][10] = ymothervertex[i][9];
2402 ymothervertex[i][11] = ymothervertex[i][0];
2403 }
2404 TGeoXtru* ssdhybridmothershape[kmothernumber];
2405 TGeoVolume* ssdhybridmother[kmothernumber];
2406 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2407 for(Int_t i=0; i<kmothernumber; i++){
2408 ssdhybridmothershape[i] = new TGeoXtru(2);
2409 ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
2410 ymothervertex[i]);
2411 ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2412 -fgkSSDChipCablesHeight[i+2]);
2413 ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
2414 ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
2415 fSSDAir);
2416 }
2417 /////////////////////////////////////////////////////////////
2418 // SSD Stiffener
2419 /////////////////////////////////////////////////////////////
2420 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2421 0.5*fgkSSDStiffenerLength,
2422 0.5*fgkSSDStiffenerWidth,
2423 0.5*fgkSSDStiffenerHeight);
2424 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2425 fSSDStiffenerMedium);
2426 ssdstiffener->SetLineColor(fColorStiffener);
2427 TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
2428 for(Int_t i=0; i<kssdstiffenernumber; i++)
2429 ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
2430 /////////////////////////////////////////////////////////////
2431 // SSD Chip System
2432 /////////////////////////////////////////////////////////////
2433 TList* ssdchipsystemlist = GetSSDChipSystem();
2434 Double_t ssdchipseparation = fgkSSDSensorLength
2435 - 2.*fgkSSDModuleStiffenerPosition[1]
2436 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
2437 - 0.5*fgkSSDChipWidth);
2438 Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
2439 + fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
2440 TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
2441 - 0.5*ssdchipsystemlength,
2442 0.5*(ssdstiffenerseparation-ssdchipseparation),
2443 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
2444////////////////////////////
2445// Capacitor 0603-2200 nF
2446///////////////////////////
2447 const Int_t knapacitor0603number = 5;
2448 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
2449 0.5*fgkSSDCapacitor0603Length,
2450 0.5*fgkSSDCapacitor0603Width,
2451 0.5*fgkSSDCapacitor0603Height);
2452 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2453 fSSDStiffener0603CapacitorMedium);
2454 capacitor0603->SetLineColor(fColorAl);
bf210566 2455 for(Int_t i=0; i<kmothernumber; i++){
2456 for(Int_t j=0; j<kssdstiffenernumber; j++){
2457 ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
2458 for(Int_t k=1; k<knapacitor0603number+1; k++){
2459 ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
2460 new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
2461 j*ssdstiffenerseparation
2462 + 0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
2463 + (j==0? -1:+1)*fgkSSDCapacitor0603Width),
2464 - 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
2465 }
2466 }
2467 ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
2468 ssdhybridlist->Add(ssdhybridmother[i]);
2469 }
2470/////////////////////////////////////////////////////////////
2471// Mother Volume Containing Capacitor Part
2472/////////////////////////////////////////////////////////////
2473 const Int_t kcapacitormothernumber = 8;
2474 Double_t xcapacitorvertex[kcapacitormothernumber];
2475 Double_t ycapacitorvertex[kcapacitormothernumber];
2476 ///////////////////////
2477 // Setting the vertices
2478 ///////////////////////
2479 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2480 xcapacitorvertex[1] = xcapacitorvertex[0];
2481 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2482 xcapacitorvertex[3] = xcapacitorvertex[2];
2483 xcapacitorvertex[4] = xcapacitorvertex[0];
2484 xcapacitorvertex[5] = xcapacitorvertex[0];
2485 xcapacitorvertex[6] = -xcapacitorvertex[0];
2486 xcapacitorvertex[7] = xcapacitorvertex[6];
2487 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2488 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2489 ycapacitorvertex[2] = ycapacitorvertex[1];
2490 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2491 ycapacitorvertex[4] = ycapacitorvertex[3];
2492 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2493 ycapacitorvertex[6] = ycapacitorvertex[5];
2494 ycapacitorvertex[7] = ycapacitorvertex[0];
2495 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2496 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2497 ycapacitorvertex);
2498 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2499 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
2500 TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2501 fSSDAir);
d7599219 2502////////////////////////////
bf210566 2503// Connector
d7599219 2504///////////////////////////
bf210566 2505 const Int_t kssdconnectornumber = 2;
2506 TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2507 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2508 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2509 + fgkSSDConnectorAlHeight};
2510 const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2511 TGeoVolume* ssdconnector[kssdconnectornumber];
2512 for(Int_t i=0; i<kssdconnectornumber; i++){
2513 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2514 0.5*fgkSSDConnectorWidth,
2515 0.5*((1-i)*fgkSSDConnectorAlHeight
2516 + i*fgkSSDConnectorNiHeight),
2517 i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2518 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2519 i==0 ? fSSDAlTraceFlexMedium
2520 : fSSDStiffenerConnectorMedium);
2521 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2522 }
2523 TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2524 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2525 + fgkSSDConnectorPosition[0]
2526 - fgkSSDConnectorSeparation
2527 - 1.5*fgkSSDConnectorLength,
2528 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2529 - fgkSSDConnectorPosition[1]
2530 - ssdconnectorshape[0]->GetDY(),0.0);
2531 ssdconnectortrans[1] = new TGeoTranslation(
2532 - ssdstiffenershape->GetDX()
2533 + fgkSSDConnectorPosition[0]
2534 - 0.5*fgkSSDConnectorLength,
2535 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2536 - fgkSSDConnectorPosition[1]
2537 - ssdconnectorshape[0]->GetDY(),0.0);
2538 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2539 - fgkSSDConnectorPosition[0]
2540 + fgkSSDConnectorSeparation
2541 + 1.5*fgkSSDConnectorLength,
2542 -(ssdstiffenershape->GetDY()
2543 - fgkSSDConnectorPosition[1]
2544 - ssdconnectorshape[0]->GetDY()),0.0);
2545 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2546 - fgkSSDConnectorPosition[0]
2547 + 0.5*fgkSSDConnectorLength,
2548 -(ssdstiffenershape->GetDY()
2549 - fgkSSDConnectorPosition[1]
2550 - ssdconnectorshape[0]->GetDY()),0.0);
2551 for(Int_t i=0; i<2*kssdconnectornumber; i++)
2552 for(Int_t j=0; j<kssdconnectornumber; j++)
2553 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2554////////////////////////////
2555// Capacitor 1812-330 nF
2556///////////////////////////
2557 Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2558 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2559 0.5*fgkSSDCapacitor1812Length,
2560 0.5*fgkSSDCapacitor1812Width,
bf210566 2561 0.5*fgkSSDCapacitor1812Height,
2562 ssdcapacitor1812origin);
44285dfa 2563 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2564 fSSDStiffener1812CapacitorMedium);
2565 capacitor1812->SetLineColor(fColorAl);
bf210566 2566 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2567 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2568 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2569 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
d7599219 2570////////////////////////////
2571//Hybrid Wire
2572////////////////////////////
44285dfa 2573 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2574 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2575 - fgkSSDConnectorSeparation;
44285dfa 2576 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2577 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
44285dfa 2578 Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
2579 + TMath::Power(wirey,2));
2580 Double_t wireangle = TMath::ATan(wirex/wirey);
2581 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2582 fgkSSDWireRadius, 0.5*ssdwireradius);
2583 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2584 fSSDStiffenerHybridWireMedium);
2585 hybridwire->SetLineColor(fColorPhynox);
2586 TGeoCombiTrans* hybridwirecombitrans[2];
2587 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2588 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2589 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2590 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2591 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2592 ssdstiffenershape->GetDZ()
2593 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
d7599219 2594 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2595 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2596 0.0,
2597 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2598 0.0,
2599 new TGeoRotation("HybridWireRot2",
2600 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2601 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2602 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2603 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2604 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2605 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2606 /////////////////////////////////////////////////////////////
bf210566 2607 // Deallocating memory
44285dfa 2608 /////////////////////////////////////////////////////////////
bf210566 2609 delete hybridwirecombitrans[0];
2610 delete hybridwirecombitrans[1];
2611 delete ssdchipsystemlist;
2612 return ssdhybridlist;
2613 /////////////////////////////////////////////////////////////
2614}
2615///////////////////////////////////////////////////////////////////////////////
2616TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2617 /////////////////////////////////////////////////////////////
2618 // SSD Cooling Block System
2619 /////////////////////////////////////////////////////////////
2620 // SSD Cooling Block and Cooling Tube Transformations
2621 /////////////////////////////////////////////////////////////
2622 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2623 localcoolingblockrot->SetAngles(0.,90.,0.);
535e8862 2624 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
bf210566 2625 TVector3* coolingblocktransvector;
2626 coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2627 + fgkSSDCoolingBlockLength,
2628 fgkSSDSensorLength
2629 - 2.*fgkSSDModuleStiffenerPosition[1]
2630 - fgkSSDCoolingBlockWidth);
2631 const Int_t kcoolingblocktransnumber = 2;
2632 const Int_t kcoolingblocknumber = 4;
2633 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2634 TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2635 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2636 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2637 TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2638 localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
535e8862 2639 0.5*fgkSSDCoolingBlockWidth,
2640 fgkSSDCoolingBlockHoleCenter);
2641 TGeoCombiTrans localcoolingtubematrix (*localcoolingtubetrans,*localcoolingtuberot);
bf210566 2642 Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2643 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
535e8862 2644 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2645 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X()+2*coolingtubedistance,
2646 j*coolingblocktransvector->Y(),
2647 - 0.5*(fgkSSDCoolingBlockHoleCenter
2648 + fgkCoolingTubeRmax));
2649 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
2650 coolingtubematrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingtubematrix);
2651 }
d7599219 2652 }
bf210566 2653 /////////////////////////////////////////////////////////////
2654 // Virtual Volume containing CoolingBlock System
2655 /////////////////////////////////////////////////////////////
2656 TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2657 const Int_t kmothervertexnumber = 16;
2658 Double_t xmothervertex[kmothervertexnumber];
2659 Double_t ymothervertex[kmothervertexnumber];
2660 ///////////////////////
2661 // Setting the vertices
2662 ///////////////////////fgkCoolingTubeSupportRmax
2663 xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2664 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2665 + fgkSSDCoolingBlockWidth;
2666 xmothervertex[2] = coolingblocktransvector->X()
2667 + fgkSSDCoolingBlockLength
2668 + 4*coolingtubedistance;
2669 ymothervertex[2] = ymothervertex[1];
2670 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2671 xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2672 ymothervertex[4] = ymothervertex[0];
2673 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2674 xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2675 ymothervertex[6] = ymothervertex[5];
2676 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2677 - fgkSSDCoolingBlockWidth;
2678 xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2679 xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2680 - coolingtubedistance;
2681 xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2682 ymothervertex[10] = ymothervertex[9];
2683 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2684 xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2685 xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2686 xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2687 ymothervertex[14] = ymothervertex[13];
2688 xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2689 //////////////////////////////////////////////////////////
2690 coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2691 xmothervertex,ymothervertex);
2692 coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2693 + fgkCoolingTubeRmax));
2694 coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2695 + fgkCoolingTubeRmax));
2696 TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
2697 coolingsystemothershape,fSSDAir);
2698 /////////////////////////////////////////////////////////////
2699 // SSD Cooling Tube Part
2700 /////////////////////////////////////////////////////////////
2701 TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
2702 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2703 0.5*fgkSSDCoolingBlockWidth);
2704 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
2705 0.5*fgkSSDCoolingBlockWidth);
2706 TGeoVolume* coolingtube[fgkcoolingtubenumber];
2707 coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
2708 fSSDCoolingTubePhynox);
2709 coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
2710 fSSDCoolingTubeWater);
2711 coolingtube[0]->SetLineColor(fColorPhynox);
2712 coolingtube[1]->SetLineColor(fColorWater);
2713 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2714 /////////////////////////////////////////////////////////////
2715 // Adding Cooling block to mother volume
2716 /////////////////////////////////////////////////////////////
2717 for(Int_t i=0; i<kcoolingblocknumber; i++){
2718 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
2719 coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
2720 coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
d7599219 2721 }
bf210566 2722 /////////////////////////////////////////////////////////////
2723 // Deallocating memory
2724 /////////////////////////////////////////////////////////////
2725 delete coolingblocktransvector;
bf210566 2726 delete localcoolingblockrot;
bf210566 2727 delete localcoolingtubetrans;
2728 delete localcoolingtuberot;
2729 /////////////////////////////////////////////////////////////
2730 // Checking overlaps
2731 /////////////////////////////////////////////////////////////
6727e2db 2732 //coolingsystemother->CheckOverlaps(0.01);
bf210566 2733 /////////////////////////////////////////////////////////////
2734 return coolingsystemother;
d7599219 2735}
2736/////////////////////////////////////////////////////////////////////////////////
bf210566 2737TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2738 /////////////////////////////////////////////////////////////
bf210566 2739 // SSD Flex
44285dfa 2740 /////////////////////////////////////////////////////////////
bf210566 2741 const Int_t kssdflexlayernumber = 2;
2742 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2743 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2744 const Int_t kmothervertexnumber = 17;
2745 Double_t xmothervertex[kmothervertexnumber];
2746 Double_t ymothervertex[kmothervertexnumber];
2747 /////////////////////////////////////////////
2748 // Auxiliary variables for vertex positioning
2749 /////////////////////////////////////////////
2750 const Int_t kssdflexboxnumber = 5;
44285dfa 2751 Double_t ssdflexboxlength[kssdflexboxnumber];
2752 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2753 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2754 * fgkSSDChipSeparationLength
2755 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2756 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2757 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2758 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2759 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2760 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2761 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2762 - ssdflexboxlength[1];
44285dfa 2763 Double_t ssdflexboxwidth[kssdflexboxnumber];
2764 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2765 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2766 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2767 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2768 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2769 ///////////////////////
2770 // Setting the vertices
2771 ///////////////////////
2772 xmothervertex[0] = 0.0;
2773 xmothervertex[1] = xmothervertex[0];
2774 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2775 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2776 + ssdflexboxlength[4];
2777 xmothervertex[4] = xmothervertex[3];
2778 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2779 xmothervertex[6] = xmothervertex[5];
2780 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2781 xmothervertex[8] = xmothervertex[7];
2782 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2783 xmothervertex[10] = xmothervertex[9];
2784 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2785 xmothervertex[12] = xmothervertex[11];
2786 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2787 xmothervertex[14] = xmothervertex[13];
2788 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2789 xmothervertex[16] = xmothervertex[15];
2790 ymothervertex[0] = 0.0;
2791 ymothervertex[1] = fgkSSDFlexWidth[1];
2792 ymothervertex[2] = fgkSSDFlexWidth[0];
2793 ymothervertex[3] = ymothervertex[2];
2794 ymothervertex[4] = ymothervertex[0];
2795 ymothervertex[5] = ymothervertex[4];
2796 ymothervertex[6] = ssdflexboxwidth[2];
2797 ymothervertex[7] = ymothervertex[6];
2798 ymothervertex[8] = ymothervertex[0];
2799 ymothervertex[9] = ymothervertex[8];
2800 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2801 ymothervertex[11] = ymothervertex[10];
2802 ymothervertex[12] = ymothervertex[0];
2803 ymothervertex[13] = ymothervertex[12];
2804 ymothervertex[14] = ymothervertex[7];
2805 ymothervertex[15] = ymothervertex[14];
2806 ymothervertex[16] = ymothervertex[0];
2807 /////////////////////////////////////////////////////////////
2808 // First Mother Volume containing SSDFlex
2809 /////////////////////////////////////////////////////////////
2810 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2811 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2812 ymothervertex);
2813 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2814 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
2815 TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2816 fSSDAir);
2817 /////////////////////////////////////////////////////////////
2818 // SSDFlex Layer Shapes
2819 /////////////////////////////////////////////////////////////
2820 for(Int_t i=0; i<kssdflexlayernumber; i++){
2821 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2822 ymothervertex);
2823 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2824 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2825 }
2826 /////////////////////////////////////
2827 // Setting Layers into Mother Volume
2828 /////////////////////////////////////
2829 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2830 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2831 fSSDKaptonFlexMedium};
2832 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2833 "AlFlexLay2","KaptonFlexLay2"};
2834 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2835 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2836 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2837 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2838 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2839 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2840 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2841 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2842 + fgkSSDFlexHeight[1]));
2843 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2844 }
6727e2db 2845 //ssdflexmother->CheckOverlaps(0.01);
bf210566 2846 return ssdflexmother;
d7599219 2847}
2848/////////////////////////////////////////////////////////////////////////////////
bf210566 2849TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2850 /////////////////////////////////////////////////////////////
2851 // Method generating SSD End Flex
d7599219 2852 /////////////////////////////////////////
bf210566 2853 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2854 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2855 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2856 * TMath::DegToRad()*ssdflexradiusmax
2857 - fgkSSDFlexLength[2]-TMath::Pi()
2858 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
2859 const Int_t knedges = 20;
2860 const Int_t karcnumber = 2;
2861 TVector3* vertexposition[karcnumber*(knedges+1)];
2862 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2863 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2864 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2865 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2866 - 90.0*TMath::DegToRad()};
2867 TVector3* referencetrans[karcnumber];
2868 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2869 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2870 radius[0]);
2871 referencetrans[1] = new TVector3(referencetrans[0]->X()
2872 + fgkSSDFlexLength[2],
2873 - fgkSSDStiffenerHeight);
2874for(Int_t i=0; i<karcnumber; i++){
2875 for(Int_t j=0; j<knedges+1; j++){
2876 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2877 radius[i]*SinD(angle[i]));
2878 angle[i] += deltangle[i]*(1.0-2.0*i);
2879 }
2880 }
2881 ///////////////////////
2882 // Setting the vertices
2883 ///////////////////////
2884 const Int_t kendflexlayernumber = 4;
2885 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2886 TVector3** vertex[kendflexlayernumber];
2887 for(Int_t i=0; i<kendflexlayernumber; i++)
2888 vertex[i] = new TVector3*[kendflexvertexnumber];
2889 TVector3* transvector[kendflexlayernumber+1];
2890 TVector3* deltatransvector = new TVector3();
2891 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2892 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2893 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2894 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2895 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2896 * CosD(fgkSSDFlexAngle),
2897 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2898 * SinD(fgkSSDFlexAngle),0.0);
2899 *transvector[i] = *transvector[i-1]+*deltatransvector;
2900 }
2901 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2902 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2903 for(Int_t i=0; i<karcnumber; i++){
2904 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2905 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2906 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2907 /radius[i];
2908 }
2909 }
2910 for(Int_t i=0; i<kendflexlayernumber; i++){
2911 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2912 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2913 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2914 if(j<(knedges+1)){
2915 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2916 vertexposition[j]->Y()*ratioradius[0][i+1]);
2917 vertex[i][j+2]->RotateZ(referenceangle[0]);
2918 *vertex[i][j+2] += *referencetrans[0];
2919 vertex[i][4*(knedges+1)-j+1] =
2920 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2921 vertexposition[j]->Y()*ratioradius[0][i]);
2922 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2923 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2924 }
2925 else{
2926
2927 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2928 vertexposition[j]->Y()*ratioradius[1][i+1]);
2929 vertex[i][j+2]->RotateZ(referenceangle[1]);
2930 *vertex[i][j+2] += *referencetrans[1];
2931 vertex[i][4*(knedges+1)-j+1] =
2932 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2933 vertexposition[j]->Y()*ratioradius[1][i]);
2934 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2935 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2936 }
2937 }
2938 }
44285dfa 2939 /////////////////////////////////////////////////////////////
bf210566 2940 // First Mother Volume containing SSDEndFlex
2941 /////////////////////////////////////////////////////////////
2942 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2943 Double_t xmothervertex[kendflexvertexnumber];
2944 Double_t ymothervertex[kendflexvertexnumber];
2945 xmothervertex[0] = vertex[0][0]->X();
2946 ymothervertex[0] = vertex[0][0]->Y();
2947 for(Int_t i=1; i<kendflexvertexnumber; i++){
2948 if(i<2*(knedges+1)+2){
2949 xmothervertex[i] = vertex[3][i]->X();
2950 ymothervertex[i] = vertex[3][i]->Y();
2951 }
2952 else{
2953 xmothervertex[i] = vertex[0][i]->X();
2954 ymothervertex[i] = vertex[0][i]->Y();
2955 }
2956 }
2957 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2958 xmothervertex,ymothervertex);
2959 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2960 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2961 TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2962 ssdendflexmothershape,fSSDAir);
2963 //////////////////////////////////////
2964 // End Flex TGeoXtru Layer Definition
2965 //////////////////////////////////////
2966 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2967 TGeoVolume* ssdendflex[kendflexlayernumber];
2968 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2969 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2970 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2971 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2972 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2973 fSSDKaptonFlexMedium};
2974 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2975 "AlEndFlexLay2","KaptonEndFlexLay2"};
2976 for(Int_t i=0; i<kendflexlayernumber; i++){
2977 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2978 xvertex[i][j] = vertex[i][j]->X();
2979 yvertex[i][j] = vertex[i][j]->Y();
2980 }
2981 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2982 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2983 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2984 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2985 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2986 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2987 ssdendflexmother->AddNode(ssdendflex[i],1);
2988 }
44285dfa 2989 /////////////////////////////////////////////////////////////
bf210566 2990 // Deallocating memory
44285dfa 2991 /////////////////////////////////////////////////////////////
bf210566 2992 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2993 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2994 for(Int_t i=0; i<kendflexlayernumber; i++){
2995 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2996 delete [] vertex[i];
2997 }
2998 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2999 delete deltatransvector;
44285dfa 3000 /////////////////////////////////////////////////////////////
6727e2db 3001 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 3002 return ssdendflexmother;
d7599219 3003}
9b0c60ab 3004///////////////////////////////////////////////////////////////////////////////
bf210566 3005TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 3006 /////////////////////////////////////////////////////////////
9b0c60ab 3007 // Method generating the Mounting Block
bf210566 3008 /////////////////////////////////////////////////////////////
9b0c60ab 3009 const Int_t kvertexnumber = 8;
3010 Double_t xvertex[kvertexnumber];
3011 Double_t yvertex[kvertexnumber];
3012 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3013 xvertex[1] = xvertex[0];
3014 xvertex[2] = -xvertex[0];
3015 xvertex[3] = xvertex[2];
3016 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
3017 - fgkSSDMountingBlockLength[2]);
3018 xvertex[5] = xvertex[4];
3019 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
3020 - 0.5*fgkSSDMountingBlockScrewHoleEdge
3021 - fgkSSDMountingBlockScrewHoleRadius[0];
3022 xvertex[7] = xvertex[6];
3023 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
e21cdd03 3024 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]
3025 - fgkSSDModuleVerticalDisalignment;
9b0c60ab 3026 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
3027 yvertex[2] = yvertex[1];
3028 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
3029 yvertex[4] = yvertex[3];
3030 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
3031 - fgkSSDMountingBlockHeight[0];
3032 yvertex[6] = yvertex[5];
3033 yvertex[7] = yvertex[0];
3034 ///////////////////////////////////////////////////////////////////////
3035 // TGeoXTru Volume definition for Mounting Block Part
3036 ///////////////////////////////////////////////////////////////////////
3037 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
3038 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
3039 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3040 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 3041 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 3042 ssdmountingblockshape,
3043 fSSDMountingBlockMedium);
3044 ssdmountingblock->SetLineColor(fColorG10);
3045 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
3046 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
3047 TGeoRotation* mountingblockrot = new TGeoRotation();
3048 mountingblockrot->SetAngles(90.,180.,-90.);
3049 mountingblockcombitrans->SetRotation(*mountingblockrot);
3050 /////////////////////////////////////////////////////////////
3051 // Generating the Mounting Block Screw Vertices
3052 /////////////////////////////////////////////////////////////
3053 const Int_t kscrewvertexnumber = 15;
3054 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
3055 - fgkSSDMountingBlockScrewHoleEdge)
3056 / fgkSSDMountingBlockScrewHoleRadius[0])
3057 * TMath::RadToDeg();
3058 Double_t phi0 = 90.+alpha;
3059 Double_t phi = 270.-2*alpha;
3060 Double_t deltaphi = phi/kscrewvertexnumber;
3061 TVector3* screwvertex[kscrewvertexnumber+1];
3062 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
3063 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
3064 *CosD(phi0+i*deltaphi),
3065 fgkSSDMountingBlockScrewHoleRadius[0]
3066 *SinD(phi0+i*deltaphi));
3067 Double_t xscrewvertex[kscrewvertexnumber+6];
3068 Double_t yscrewvertex[kscrewvertexnumber+6];
3069 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
3070 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
3071 - fgkSSDMountingBlockScrewHoleEdge);
3072 xscrewvertex[1] = xscrewvertex[0];
3073 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3074 xscrewvertex[2] = screwvertex[0]->X();
3075 yscrewvertex[2] = yscrewvertex[1];
3076 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
3077 xscrewvertex[i+3] = screwvertex[i]->X();
3078 yscrewvertex[i+3] = screwvertex[i]->Y();
3079 }
3080 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3081 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
3082 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
3083 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
3084 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
3085 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
3086 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
3087 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
3088 + fgkSSDMountingBlockHeight[2]);
3089 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
3090 ssdmountingblockscrewshape,
3091 fSSDMountingBlockMedium);
3092 ssdmountingblockscrew->SetLineColor(fColorG10);
3093 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
3094 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
3095 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3096 - yscrewvertex[1],
3097 0.5*fgkSSDMountingBlockHeight[0]
3098 - fgkSSDMountingBlockHeight[2]
3099 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3100 + fgkSSDMountingBlockHeight[2]
3101 - yvertex[0]));
3102 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3103 -0.5*fgkSSDMountingBlockScrewHoleEdge,
3104 yscrewvertex[1]
3105 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3106 +fgkSSDMountingBlockHeight[2]
3107 -yvertex[0]));
3108 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3109 yscrewvertex[1],
3110 - 0.5*fgkSSDMountingBlockHeight[0]
3111 + fgkSSDMountingBlockHeight[2]
3112 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3113 + fgkSSDMountingBlockHeight[2]
3114 - yvertex[0]));
3115 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3116 yscrewvertex[1],
3117 - yscrewvertex[1]
3118 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3119 + fgkSSDMountingBlockHeight[2]
3120 - yvertex[0]));
3121 TGeoRotation* ssdmountingblockscrewrot[4];
3122 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3123 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3124 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3125 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3126 for(Int_t i=1; i<4; i++)
3127 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3128 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3129 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3130 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3131 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3132 + xvertex[0],yscrewvertex[1]
3133 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3134 + fgkSSDMountingBlockHeight[2]
3135 - yvertex[0]),0.);
3136 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3137 for(Int_t i=0; i<4; i++){
3138 ssdmountingblockscrewmatrix[i] =
3139 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3140 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3141 }
3142 ///////////////////////////////////////////////////////////////////////
3143 // TGeoXtru for Mother Volume
3144 ///////////////////////////////////////////////////////////////////////
3145 const Int_t kvertexmothernumber = 12;
3146 Double_t xmothervertex[kvertexmothernumber];
3147 Double_t ymothervertex[kvertexmothernumber];
3148 for(Int_t i=0; i<6; i++){
3149 xmothervertex[i] = xvertex[i];
3150 ymothervertex[i] = yvertex[i];
3151 }
3152 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3153 ymothervertex[6] = ymothervertex[5];
3154 xmothervertex[7] = xmothervertex[6];
3155 ymothervertex[7] = ymothervertex[4];
3156 xmothervertex[8] = xmothervertex[7]
3157 + 0.5*(fgkSSDMountingBlockLength[1]
3158 - fgkSSDMountingBlockLength[2]);
3159 ymothervertex[8] = ymothervertex[4];
3160 xmothervertex[9] = xmothervertex[8];
3161 ymothervertex[9] = ymothervertex[2];
3162 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3163 ymothervertex[10] = ymothervertex[1];
3164 xmothervertex[11] = xmothervertex[10];
3165 ymothervertex[11] = ymothervertex[0];
3166 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3167 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3168 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3169 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3170 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3171 ssdmountingblockmothershape,
3172 fSSDAir);
3173 /////////////////////////////////////////////////////////////
3174 // Placing the Volumes into Mother Volume
3175 /////////////////////////////////////////////////////////////
3176 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3177 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3178 for(Int_t i=0; i<4; i++)
3179 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3180 ssdmountingblockscrewmatrix[i]);
3181 /////////////////////////////////////////////////////////////
3182 // Deallocating memory
3183 /////////////////////////////////////////////////////////////
3184 delete mountingblockrot;
3185 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3186 delete ssdmountingblockglobalrot;
3187 delete ssdmountingblockglobaltrans;
3188 /////////////////////////////////////////////////////////////
3189 return ssdmountingblockmother;
3190}
3191///////////////////////////////////////////////////////////////////////////////
3192 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3193 /////////////////////////////////////////////////////////////
3194 // Method generating the Mounting Block Clip
3195 /////////////////////////////////////////////////////////////
3196 const Int_t kmothervertexnumber = 10;
3197 Double_t xmothervertex[kmothervertexnumber];
3198 Double_t ymothervertex[kmothervertexnumber];
3199 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3200 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3201 xmothervertex[1] = xmothervertex[0];
3202 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3203 - fgkMountingBlockClibScrewRadius);
3204 xmothervertex[3] = xmothervertex[2];
3205 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3206 xmothervertex[5] = xmothervertex[4];
3207 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3208 xmothervertex[7] = xmothervertex[6];
3209 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3210 xmothervertex[9] = xmothervertex[8];
3211 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
e21cdd03 3212 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0]
3213 - fgkSSDModuleVerticalDisalignment;
9b0c60ab 3214 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3215 ymothervertex[2] = ymothervertex[1];
3216 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3217 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3218 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3219 ymothervertex[4] = ymothervertex[3];
3220 ymothervertex[5] = ymothervertex[2];
3221 ymothervertex[6] = ymothervertex[5];
3222 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3223 ymothervertex[8] = ymothervertex[7];
3224 ymothervertex[9] = ymothervertex[0];
3225 ///////////////////////////////////////////////////////////////////////
3226 // TGeoXTru Volume definition for Mounting Block Clip Part
3227 ///////////////////////////////////////////////////////////////////////
3228 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3229 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3230 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3231 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3232 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3233 ssdmountingblockclipshape,fSSDAir);
3234 ssdmountingblockclip->SetLineColor(4);
3235 ///////////////////////////////////////////////////////////////////////
3236 // TGeoXTru Volume definition for Clip
3237 ///////////////////////////////////////////////////////////////////////
3238 const Int_t kclipvertexnumber = 6;
3239 Double_t xclipvertex[kclipvertexnumber];
3240 Double_t yclipvertex[kclipvertexnumber];
3241 xclipvertex[0] = xmothervertex[0];
3242 xclipvertex[1] = xclipvertex[0];
3243 xclipvertex[2] = xmothervertex[6];
3244 xclipvertex[3] = xclipvertex[2];
3245 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3246 xclipvertex[5] = xclipvertex[4];
3247 yclipvertex[0] = ymothervertex[0];
3248 yclipvertex[1] = ymothervertex[1];
3249 yclipvertex[2] = yclipvertex[1];
3250 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3251 yclipvertex[4] = yclipvertex[3];
3252 yclipvertex[5] = yclipvertex[0];
3253 TGeoXtru* clipshape = new TGeoXtru(2);
3254 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3255 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3256 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3257 + fgkMountingBlockClibWidth);
3258 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3259 clip->SetLineColor(18);
3260 ///////////////////////////////////////////////////////////////////////
3261 // Ladder Support Piece
3262 ///////////////////////////////////////////////////////////////////////
3263 const Int_t ksupportvertexnumber = 4;
3264 Double_t xsupportvertex[ksupportvertexnumber];
3265 Double_t ysupportvertex[ksupportvertexnumber];
3266 xsupportvertex[0] = xclipvertex[5];
3267 xsupportvertex[1] = xsupportvertex[0];
3268 xsupportvertex[2] = xmothervertex[9];
3269 xsupportvertex[3] = xsupportvertex[2];
3270 ysupportvertex[0] = yclipvertex[0];
3271 ysupportvertex[1] = yclipvertex[3];
3272 ysupportvertex[2] = ysupportvertex[1];
3273 ysupportvertex[3] = ysupportvertex[0];
3274 TGeoXtru* supportshape = new TGeoXtru(2);
3275 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3276 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3277 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3278 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3279 support->SetLineColor(9);
3280 ///////////////////////////////////////////////////////////////////////
3281 // TGeoXTru Volume definition for Screw
3282 ///////////////////////////////////////////////////////////////////////
3283 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3284 0.5*fgkMountingBlockClibScrewRadius};
3285 Int_t edgesnumber[2] = {50,6};
3286 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3287 +0.5*(ymothervertex[3]-ymothervertex[2])};
3288 TGeoXtru* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
3289 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3290 clipscrew->SetLineColor(12);
3291 TGeoRotation* screwrot = new TGeoRotation();
3292 screwrot->SetAngles(0.,90.,0.);
3293 TGeoTranslation* screwtrans = new TGeoTranslation();
3294 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3295 0.5*(ymothervertex[3]+ymothervertex[2]),
3296 0.5*fgkSSDMountingBlockWidth+
3297 -0.5*fgkMountingBlockSupportWidth[0]);
3298 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3299 ///////////////////////////////////////////////////////////////////////
3300 // Placing the Volumes
3301 ///////////////////////////////////////////////////////////////////////
3302 ssdmountingblockclip->AddNode(clip,1);
3303 ssdmountingblockclip->AddNode(support,1);
3304 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3305 /////////////////////////////////////////////////////////////
3306 // Deallocating memory
3307 /////////////////////////////////////////////////////////////
3308 delete screwtrans;
3309 delete screwrot;
3310 /////////////////////////////////////////////////////////////
3311 return ssdmountingblockclip;
d7599219 3312}
bf210566 3313///////////////////////////////////////////////////////////////////////////////
3314TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{
44285dfa 3315 /////////////////////////////////////////////////////////////
bf210566 3316 // Method generating the Cooling Tube
44285dfa 3317 /////////////////////////////////////////////////////////////
bf210566 3318 TGeoTube** coolingtubeshape[fgkcoolingtubenumber];
3319 for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtubeshape[i] =
3320 new TGeoTube*[2];
9b0c60ab 3321 // Ladder Cooling Tubes
bf210566 3322 coolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3323 0.25 * (fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3324 - 2.*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth));
3325 coolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3326 coolingtubeshape[0][0]->GetDz());
3327 coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3328 0.5*(fgkSSDModuleStiffenerPosition[1]
3329 - fgkSSDSensorOverlap));
3330 coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3331 coolingtubeshape[1][0]->GetDz());
3332 coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3333 0.5*fgkSSDModuleStiffenerPosition[1]);
3334 coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3335 coolingtubeshape[2][0]->GetDz());
9b0c60ab 3336 // End Ladder Cooling Tubes
3337 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3338 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3339 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3340 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3341 0.50 * (fgkEndLadderMountingBlockPosition[0]
3342 - fgkendladdercoolingsupportdistance[0]));
3343 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3344 endladdercoolingtubeshape[0][0]->GetDz());
3345 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3346 0.50 * (fgkendladdercoolingsupportdistance[0]
3347 + fgkendladdercoolingsupportdistance[1]
3348 - fgkCoolingTubeSupportWidth));
3349 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3350 endladdercoolingtubeshape[1][0]->GetDz());
3351 endladdercoolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3352 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
3353 - fgkEndLadderMountingBlockPosition[0]
3354 - fgkendladdercoolingsupportdistance[1]
3355 - fgkCoolingTubeSupportWidth));
3356 endladdercoolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3357 endladdercoolingtubeshape[2][0]->GetDz());
3358 endladdercoolingtubeshape[3][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3359 0.50 * (fgkMountingBlockToSensorSupport
3360 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
3361 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
3362 + fgkSSDSensorOverlap
3363 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
3364 - fgkendladdercoolingsupportdistance[2]
3365 - fgkEndLadderMountingBlockPosition[1]
3366 - fgkCoolingTubeSupportWidth));
3367 endladdercoolingtubeshape[3][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3368 endladdercoolingtubeshape[3][0]->GetDz());
3369 endladdercoolingtubeshape[4][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3370 0.50 * fgkendladdercoolingsupportdistance[2]);
3371 endladdercoolingtubeshape[4][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3372 endladdercoolingtubeshape[4][0]->GetDz());
3373 // Ladder Cooling Tubes
bf210566 3374 TGeoVolume** coolingtube[fgkcoolingtubenumber];
3375 for(Int_t i=0; i<fgkcoolingtubenumber; i++) coolingtube[i] =
3376 new TGeoVolume*[2];
3377 coolingtube[0][0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0][0],
3378 fSSDCoolingTubePhynox);
3379 coolingtube[0][1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[0][1],
3380 fSSDCoolingTubeWater);
3381 coolingtube[1][0] = new TGeoVolume("OuterCoolingTube2",coolingtubeshape[1][0],
3382 fSSDCoolingTubePhynox);
3383 coolingtube[1][1] = new TGeoVolume("InnerCoolingTube2",coolingtubeshape[1][1],
3384 fSSDCoolingTubeWater);
3385 coolingtube[2][0] = new TGeoVolume("OuterCoolingTube3",coolingtubeshape[2][0],
3386 fSSDCoolingTubePhynox);
3387 coolingtube[2][1] = new TGeoVolume("InnerCoolingTube3",coolingtubeshape[2][1],
3388 fSSDCoolingTubeWater);
3389 for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3390 coolingtube[i][0]->SetLineColor(fColorPhynox);
3391 coolingtube[i][1]->SetLineColor(fColorWater);
3392 }
9b0c60ab 3393 // End Ladder Cooling Tubes
3394 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3395 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3396 endladdercoolingtube[i] = new TGeoVolume*[2];
3397 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3398 endladdercoolingtubeshape[0][0],
3399 fSSDCoolingTubePhynox);
3400 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3401 endladdercoolingtubeshape[0][1],
3402 fSSDCoolingTubeWater);
3403 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3404 endladdercoolingtubeshape[1][0],
3405 fSSDCoolingTubePhynox);
3406 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3407 endladdercoolingtubeshape[1][1],
3408 fSSDCoolingTubeWater);
3409 endladdercoolingtube[2][0] = new TGeoVolume("OuterEndLadderCoolingTube3",
3410 endladdercoolingtubeshape[2][0],
3411 fSSDCoolingTubePhynox);
3412 endladdercoolingtube[2][1] = new TGeoVolume("InnerEndlLadderCoolingTube3",
3413 endladdercoolingtubeshape[2][1],
3414 fSSDCoolingTubeWater);
3415 endladdercoolingtube[3][0] = new TGeoVolume("OuterEndLadderCoolingTube4",
3416 endladdercoolingtubeshape[3][0],
3417 fSSDCoolingTubePhynox);
3418 endladdercoolingtube[3][1] = new TGeoVolume("InnerEndlLadderCoolingTube4",
3419 endladdercoolingtubeshape[3][1],
3420 fSSDCoolingTubeWater);
3421 endladdercoolingtube[4][0] = new TGeoVolume("OuterEndLadderCoolingTube5",
3422 endladdercoolingtubeshape[4][0],
3423 fSSDCoolingTubePhynox);
3424 endladdercoolingtube[4][1] = new TGeoVolume("InnerEndlLadderCoolingTube5",
3425 endladdercoolingtubeshape[4][1],
3426 fSSDCoolingTubeWater);
3427 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3428 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3429 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3430 }
bf210566 3431 /////////////////////////////////////////////////////////////
3432 // Virtual Volume containing Cooling Tubes
3433 /////////////////////////////////////////////////////////////
9b0c60ab 3434 // Ladder Cooling Tubes
bf210566 3435 TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber];
3436 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
3437 virtualcoolingtubeshape[i] = new TGeoTube(coolingtubeshape[i][1]->GetRmin(),
3438 coolingtubeshape[i][0]->GetRmax(),
3439 coolingtubeshape[i][0]->GetDz());
3440 TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber];
3441 virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0],
3442 fSSDAir);
3443 virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1],
3444 fSSDAir);
3445 virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2],
3446 fSSDAir);
9b0c60ab 3447 // End Ladder Cooling Tubes
3448 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3449 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3450 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3451 endladdercoolingtubeshape[i][0]->GetRmax(),
3452 endladdercoolingtubeshape[i][0]->GetDz());
3453 TGeoVolume* endladdervirtualcoolingtube[fgkendladdercoolingtubenumber];
3454 endladdervirtualcoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3455 endladdervirtualcoolingtubeshape[0],
3456 fSSDAir);
3457 endladdervirtualcoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3458 endladdervirtualcoolingtubeshape[1],
3459 fSSDAir);
3460 endladdervirtualcoolingtube[2] = new TGeoVolume("EndLadderCoolingTube3",
3461 endladdervirtualcoolingtubeshape[2],
3462 fSSDAir);
3463 endladdervirtualcoolingtube[3] = new TGeoVolume("EndLadderCoolingTube4",
3464 endladdervirtualcoolingtubeshape[3],
3465 fSSDAir);
3466 endladdervirtualcoolingtube[4] = new TGeoVolume("EndLadderCoolingTube5",
3467 endladdervirtualcoolingtubeshape[4],
3468 fSSDAir);
bf210566 3469 TList* coolingtubelist = new TList();
3470 for(Int_t i=0; i<fgkcoolingtubenumber; i++){
3471 virtualcoolingtube[i]->AddNode(coolingtube[i][0],1);
3472 virtualcoolingtube[i]->AddNode(coolingtube[i][1],1);
3473 coolingtubelist->Add(virtualcoolingtube[i]);
d7599219 3474 }
9b0c60ab 3475 endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3476 endladdervirtualcoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3477 coolingtubelist->Add(endladdervirtualcoolingtube[0]);
3478 endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3479 endladdervirtualcoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
3480 coolingtubelist->Add(endladdervirtualcoolingtube[1]);
3481 endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][0],1);
3482 endladdervirtualcoolingtube[2]->AddNode(endladdercoolingtube[2][1],1);
3483 coolingtubelist->Add(endladdervirtualcoolingtube[2]);
3484 endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][0],1);
3485 endladdervirtualcoolingtube[3]->AddNode(endladdercoolingtube[3][1],1);
3486 coolingtubelist->Add(endladdervirtualcoolingtube[3]);
3487 endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][0],1);
3488 endladdervirtualcoolingtube[4]->AddNode(endladdercoolingtube[4][1],1);
3489 coolingtubelist->Add(endladdervirtualcoolingtube[4]);
bf210566 3490 return coolingtubelist;
d7599219 3491}
bf210566 3492///////////////////////////////////////////////////////////////////////////////
3493TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3494 /////////////////////////////////////////////////////////////
bf210566 3495 // Method generating SSD Cooling Block
44285dfa 3496 /////////////////////////////////////////////////////////////
bf210566 3497 const Int_t kvertexnumber = 8;
3498 ///////////////////////////////////////
3499 // Vertex Positioning for TGeoXTru
3500 ///////////////////////////////////////
3501 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3502 vertexposition[0] = new TVector3(0.0,0.0);
3503 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3504 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3505 vertexposition[1]->Y());
3506 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3507 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3508 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3509 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3510 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3511 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3512 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3513 - fgkSSDCoolingBlockHoleLength[0]
3514 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3515 fgkSSDCoolingBlockHeight[0]
3516 - fgkSSDCoolingBlockHoleRadius[1],
3517 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3518 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3519 - fgkSSDCoolingBlockHoleLength[0]),
3520 vertexposition[6]->Y());
3521 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3522 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3523 Double_t phi = 180.-alpha;
3524 Double_t psi = 180.+2.*alpha;
3525 Double_t deltapsi = psi/nedges;
3526 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3527 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3528 fgkSSDCoolingBlockHoleCenter);
3529 for(Int_t i=0; i<nedges+1; i++){
3530 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3531 radius*SinD(phi+i*deltapsi));
3532 *vertexposition[kvertexnumber+i] += (*transvector);
3533 }
3534 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3535 for(Int_t i=0; i<kvertexnumber; i++)
3536 vertexposition[kvertexnumber+nedges+1+i] =
3537 GetReflection(vertexposition[kvertexnumber-1-i],param);
3538 ///////////////////////////////////////////////////////////////////////
3539 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3540 ///////////////////////////////////////////////////////////////////////
3541 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3542 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3543 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3544 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3545 xvertexpoints[i] = vertexposition[i]->X();
3546 yvertexpoints[i] = vertexposition[i]->Y();
3547 }
3548 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3549 yvertexpoints);
3550 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3551 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3552 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3553 ssdcoolingblockshape,
3554 fSSDAlCoolBlockMedium);
3555 ssdcoolingblock->SetLineColor(fColorAl);
3556 /////////////////////////////////////////////////////////////
3557 // Deallocating memory
3558 /////////////////////////////////////////////////////////////
3559 delete [] vertexposition;
3560 delete xvertexpoints;
3561 delete yvertexpoints;
3562 /////////////////////////////////////////////////////////////
3563 return ssdcoolingblock;
3564}
3565/////////////////////////////////////////////////////////////////////////////////
3566TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){
d7599219 3567 ///////////////////////////////////////////////////////
bf210566 3568 const Int_t kssdchipcablesnumber = 2;
3569 const Int_t kssdchipcableslaynumber = 2;
3570 const Int_t kvertexnumber = 4*(nedges+1)+4;
3571 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3572 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
3573 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
3574 - fgkSSDChipCablesHeight[0]
3575 - fgkSSDChipCablesHeight[1]);
3576 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3577 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3578 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3579 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3580 - ssdchipcablesradius[0]
3581 - fgkSSDChipCablesWidth[1]
3582 - fgkSSDChipCablesWidth[2]);
3583 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3584 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3585 + fgkSSDChipCablesHeight[1]
3586 + fgkSSDSensorHeight);
d7599219 3587 ///////////////////////////////////////////////////////
bf210566 3588 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3589 ///////////////////////////////////////////////////////
3590 TVector3** vertexposition[kssdchipcableslaynumber];
3591 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3592 new TVector3*[4*(nedges+1)+4];
3593 Double_t ratio[4];
3594 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3595 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3596 / ssdchipcablesradius[0];
3597 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3598 / ssdchipcablesradius[0];
3599 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3600 + fgkSSDChipCablesHeight[1])
3601 / ssdchipcablesradius[0];
3602 Double_t phi = 180.;
3603 Double_t deltaphi = 180./nedges;
3604 Double_t angle = 0.0;
3605 Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3606 Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3607 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3608 xvertexpoints[i] = new Double_t[kvertexnumber];
3609 yvertexpoints[i] = new Double_t[kvertexnumber];
3610 }
3611 TVector3* vertex = new TVector3();
3612 TVector3* transvector[kssdchipcableslaynumber];
3613 transvector[0] = new TVector3(fgkSSDChipWidth,
3614 SSDChipCablesHeigth-ssdchipcablesradius[0]);
3615 transvector[1] = new TVector3();
3616 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcableslaynumber];
3617 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcableslaynumber];
3618 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcableslaynumber] =
3619 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3620 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3621 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3622 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3623 transvector[1]->SetY(ssdchipcablesradius[0]
3624 + fgkSSDChipCablesHeight[0]
3625 + fgkSSDChipCablesHeight[1]);
3626 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3627 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeigth
3628 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
3629 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeigth
3630 - i*fgkSSDChipCablesHeight[0]);
3631 vertexposition[i][2*(nedges+1)+2] =
3632 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3633 + fgkSSDChipCablesWidth[1]
3634 + fgkSSDChipCablesWidth[2],
3635 ((1.-i)*fgkSSDChipCablesHeight[i]
3636 + fgkSSDChipCablesHeight[1]));
3637 vertexposition[i][2*(nedges+1)+3] =
3638 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3639 vertexposition[i][2*(nedges+1)+2]->Y()
3640 - fgkSSDChipCablesHeight[i]);
3641 for(Int_t j=0; j<nedges+1; j++){
3642 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3643 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3644 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3645 vertexposition[0][(nedges+1)*i+j+2] =
3646 new TVector3(*vertex+*transvector[i]);
3647 vertexposition[1][(nedges+1)*i+j+2] =
3648 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3649 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3650 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3651 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3652 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3653 new TVector3(vertex->X()*ratio[2*i+1]
3654 + transvector[i]->X(),
3655 vertex->Y()*ratio[2*i+1]
3656 + transvector[i]->Y());
3657 }
3658 }
3659 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3660 for(Int_t j=0; j<kvertexnumber; j++){
3661 xvertexpoints[i][j] = vertexposition[i][j]->X();
3662 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3663 }
3664 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3665 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3666 xvertexpoints[i],yvertexpoints[i]);
3667 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3668 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3669 ssdchipcable[kssdchipcablesnumber*k+i] =
3670 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3671 ssdchipcableshape[kssdchipcablesnumber*k+i],
3672 (kssdchipcablesnumber*k+i)%2==0?
3673 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3674 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3675 }
3676 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3677 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3678 }
44285dfa 3679 /////////////////////////////////////////////////////////////
bf210566 3680 // Mother Volume definition
3681 /////////////////////////////////////////////////////////////
3682 Double_t ssdchipseparation = fgkSSDSensorLength
3683 - 2.*fgkSSDModuleStiffenerPosition[1]
3684 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3685 - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth;
3686 Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth};
3687 Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0]
3688 +fgkSSDChipCablesWidth[1]
3689 +fgkSSDChipCablesWidth[2]);
3690 Double_t dy = fgkSSDChipCablesLength[1];
3691 Double_t dz = SSDChipCablesHeigth;
3692 TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin);
3693 TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother",
3694 ssdchipcablesmotherbox,fSSDAir);
3695 /////////////////////////////////////////////////////////////
3696 // Rotation and Translation Definition for positioning
3697 /////////////////////////////////////////////////////////////
3698 TGeoRotation* ssdchipcablesrot[5];
3699 ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90);
3700 ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0);
3701 ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0]));
3702 ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0);
3703 ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2]));
3704 TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation,
3705 0.,0.,ssdchipcablesrot[2]);
3706 ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]);
3707 ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]);
3708 ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans);
3709 ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans);
3710 /////////////////////////////////////////////////////////////
3711 // Deallocating memory
3712 /////////////////////////////////////////////////////////////
3713 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3714 delete [] xvertexpoints[i];
3715 delete [] yvertexpoints[i];
3716 }
3717 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3718 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3719 delete vertex;
3720 delete ssdchipcablesrot[0];
3721 delete ssdchipcablesrot[1];
3722 delete ssdchipcablesrot[3];
3723 /////////////////////////////////////////////////////////////
3724 return ssdchipcablesmother;
d7599219 3725}
bf210566 3726///////////////////////////////////////////////////////////////////////////////
3727TList* AliITSv11GeometrySSD::GetSSDChipSystem(){
3728 /////////////////////////////////////////////////////////////
3729 // SSD Chip Assembly
3730 /////////////////////////////////////////////////////////////
3731 TGeoVolume* ssdchipassembly = GetSSDChips();
3732 TList* ssdchipsystemlist = new TList();
e21cdd03 3733// const Int_t knedges = 20;
3734 const Int_t knedges = 5;
bf210566 3735 const Int_t kchipsystemnumber = 2;
3736 /////////////////////////////////////////////////////////////
3737 // Mother Volume containing SSDChipSystem
3738 /////////////////////////////////////////////////////////////
3739 TGeoXtru* chipsystemothershape[kchipsystemnumber];
3740 for(Int_t i=0; i<kchipsystemnumber; i++) chipsystemothershape[i] = new TGeoXtru(2);
3741 const Int_t kmothervertexnumber = 12;
3742 Double_t xmothervertex[kchipsystemnumber][kmothervertexnumber];
3743 Double_t ymothervertex[kchipsystemnumber][kmothervertexnumber];
3744 Double_t ssdchipcablesradius[kchipsystemnumber];
3745 Double_t ssdchipseparation = fgkSSDSensorLength
3746 - 2.*fgkSSDModuleStiffenerPosition[1]
3747 - 2.*(fgkSSDStiffenerWidth
3748 - fgkSSDStiffenerToChipDist-0.5*fgkSSDChipWidth);
3749 for(Int_t i=0; i<kchipsystemnumber; i++)
3750 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
3751 - fgkSSDChipCablesHeight[0]
3752 - fgkSSDChipCablesHeight[1]);
3753 ///////////////////////
3754 // Setting the vertices
3755 ///////////////////////
3756 xmothervertex[0][0] = -0.5*fgkSSDChipCablesLength[1];
3757 xmothervertex[0][1] = xmothervertex[0][0];
3758 xmothervertex[0][2] = (fgkSSDChipNumber-1)*(fgkSSDChipLength
3759 + fgkSSDChipSeparationLength)+0.5*fgkSSDChipCablesLength[1];
3760 xmothervertex[0][3] = xmothervertex[0][2];
3761 xmothervertex[0][4] = 0.5*fgkSSDChipCablesLength[1];
3762 xmothervertex[0][5] = xmothervertex[0][4];
3763 xmothervertex[0][6] = xmothervertex[0][2]-0.5*fgkSSDChipCablesLength[1];
3764 xmothervertex[0][7] = xmothervertex[0][6];
3765 xmothervertex[0][8] = 0.0;
3766 xmothervertex[0][9] = xmothervertex[0][8];
3767 xmothervertex[0][10] = xmothervertex[0][4];
3768 xmothervertex[0][11] = xmothervertex[0][10];
3769 for(Int_t i=0; i<kmothervertexnumber; i++)
3770 xmothervertex[1][i] = xmothervertex[0][i];
3771 for(Int_t i=0; i<kchipsystemnumber; i++){
3772 ymothervertex[i][0] = -0.5*fgkSSDChipWidth-ssdchipcablesradius[i]
3773 - fgkSSDChipCablesWidth[1]-fgkSSDChipCablesWidth[2];
3774 ymothervertex[i][1] = ssdchipseparation-ymothervertex[i][0];
3775 ymothervertex[i][2] = ymothervertex[i][1];
3776 ymothervertex[i][3] = ymothervertex[i][0];
3777 ymothervertex[i][4] = ymothervertex[i][0];
3778 ymothervertex[i][5] = 0.5*fgkSSDChipWidth;
3779 ymothervertex[i][6] = ymothervertex[i][5];
3780 ymothervertex[i][7] = ssdchipseparation-0.5*fgkSSDChipWidth;
3781 ymothervertex[i][8] = ymothervertex[i][7];
3782 ymothervertex[i][9] = ymothervertex[i][5];
3783 ymothervertex[i][10] = ymothervertex[i][5];
3784 ymothervertex[i][11] = ymothervertex[i][4];
3785 }
3786 //////////////////////////////////////////////////////////
3787 TGeoVolume* chipsystemother[kchipsystemnumber];
3788 const char* chipsytemothername[kchipsystemnumber] =
3789 {"SSDChipSytemother1","SSDChipSytemother2"};
3790 for(Int_t i=0; i<kchipsystemnumber; i++){
3791 chipsystemothershape[i]->DefinePolygon(kmothervertexnumber,
3792 xmothervertex[i],ymothervertex[i]);
3793 chipsystemothershape[i]->DefineSection(0,-fgkSSDChipCablesHeight[i+2]
3794 -0.5*fgkSSDChipHeight);
3795 chipsystemothershape[i]->DefineSection(1,0.5*fgkSSDChipHeight);
3796 chipsystemother[i] = new TGeoVolume(chipsytemothername[i],
3797 chipsystemothershape[i],fSSDAir);
3798 }
44285dfa 3799 /////////////////////////////////////////////////////////////
bf210566 3800 // SSD Chip Cables
3801 /////////////////////////////////////////////////////////////
3802 TGeoVolume* ssdchipcables[kchipsystemnumber];
3803 TGeoRotation** ssdchipcablesrot[kchipsystemnumber];
3804 TGeoTranslation** ssdchipcablestrans[kchipsystemnumber];
3805 TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber];
3806 //////////////////
3807 for(Int_t i=0; i<kchipsystemnumber; i++){
3808 ssdchipcables[i] =
3809 GetSSDChipCables(fgkSSDChipCablesHeight[i+2],knedges);
3810 ssdchipcablestrans[i] = new TGeoTranslation*[fgkSSDChipNumber];
3811 ssdchipcablesrot[i] = new TGeoRotation*[fgkSSDChipNumber];
3812 ssdchipcablescombitrans[i] = new TGeoCombiTrans*[fgkSSDChipNumber];
3813 }
3814 for(Int_t i=0; i<kchipsystemnumber; i++){
3815 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3816 ssdchipcablestrans[i][j] = new TGeoTranslation();
3817 ssdchipcablesrot[i][j] = new TGeoRotation();
3818 ssdchipcablescombitrans[i][j] = new TGeoCombiTrans();
3819 ssdchipcablesrot[i][j]->SetAngles(-90.0,0.0,0.0);
3820 ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength
3821 + fgkSSDChipSeparationLength),
3822 0.5*fgkSSDChipWidth,
3823 - 0.5*fgkSSDChipHeight
3824 - fgkSSDChipCablesHeight[i+2]);
3825 ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]);
3826 ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]);
3827 chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]);
bf210566 3828 }
3829 chipsystemother[i]->AddNode(ssdchipassembly,i+1);
e21cdd03 3830 ssdchipsystemlist->Add(chipsystemother[i]);
bf210566 3831 }
3832 /////////////////////////////////////////////////////////////
3833 // Deallocating memory
3834 /////////////////////////////////////////////////////////////
3835 for(Int_t i=0; i<kchipsystemnumber; i++){
3836 for(Int_t j=0; j<fgkSSDChipNumber; j++){
3837 delete ssdchipcablesrot[i][j];
3838 delete ssdchipcablestrans[i][j];
3839 }
3840 delete ssdchipcablesrot[i];
3841 delete ssdchipcablestrans[i];
3842 }
3843 /////////////////////////////////////////////////////////////
3844 return ssdchipsystemlist;
d7599219 3845}
bf210566 3846///////////////////////////////////////////////////////////////////////////////
3847TGeoVolume* AliITSv11GeometrySSD::GetSSDChips() const{
44285dfa 3848 /////////////////////////////////////////////////////////////
bf210566 3849 // SSD Chip Assembly Generation
3850 /////////////////////////////////////////////////////////////
3851 const Int_t kssdchiprownumber = 2;
3852 TGeoBBox* ssdchipcompshape[2];
3853 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3854 0.5*fgkSSDChipLength,
3855 0.5*fgkSSDChipWidth,
3856 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3857 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3858 0.5*fgkSSDChipLength,
3859 0.5*fgkSSDChipWidth,
3860 0.5*fgkSSDChipGlueHeight);
3861 TGeoVolume* ssdchipcomp[2];
3862 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3863 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3864 fSSDChipGlueMedium);
3865 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3866 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3867 TGeoTranslation* ssdchipcomptrans[2];
3868 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3869 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3870 /////////////////////////////////////////////////////////////
3871 // Virtual Volume containing SSDChip
3872 /////////////////////////////////////////////////////////////
3873 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3874 0.5*fgkSSDChipWidth,
3875 0.5*fgkSSDChipHeight);
e21cdd03 3876 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
bf210566 3877 /////////////////////////////////////////////////////////////
3878 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3879 Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
3880 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
3881 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
3882 - 0.5*fgkSSDChipWidth)};
3883 /////////////////////////////////////////////////////////////
3884 // Virtual Volume containing SSDChipAssembly
3885 /////////////////////////////////////////////////////////////
3886 TGeoXtru* ssdchipmothershape = new TGeoXtru(2);
3887 const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber;
3888 Double_t xmothervertex[kssdmothervertexnumber];
3889 Double_t ymothervertex[kssdmothervertexnumber];
3890 ///////////////////////
3891 // Setting the vertices
3892 ///////////////////////
3893 xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth;
3894 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1]
3895 - ymothervertex[0];
3896 xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0];
3897 ymothervertex[2] = ymothervertex[1];
3898 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
3899 xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0];
3900 ymothervertex[4] = ymothervertex[0];
3901 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4];
3902 xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0]
3903 + (0.5*fgkSSDChipLength-fgkSSDChipWidth);
3904 ymothervertex[6] = ymothervertex[5];
3905 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
3906 - fgkSSDChipWidth;
3907 xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3908 ymothervertex[8] = ymothervertex[7];
3909 xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth;
3910 ymothervertex[9] = ymothervertex[6];
3911 xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9];
3912 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0];
3913 //////////////////////////////////////////////////////////
3914 ssdchipmothershape->DefinePolygon(kssdmothervertexnumber,
3915 xmothervertex,ymothervertex);
3916 ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight);
3917 ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight);
3918 TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer",
3919 ssdchipmothershape,fSSDAir);
3920 /////////////////////////////////////////////////////////////
3921 for(Int_t i=0; i<kssdchiprownumber; i++)
3922 for(Int_t j=0; j<fgkSSDChipNumber; j++)
3923 ssdchipmother->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
3924 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
3925 return ssdchipmother;
d7599219 3926}
bf210566 3927/////////////////////////////////////////////////////////////////////////////////
3928TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3929 /////////////////////////////////////////////////////////////
bf210566 3930 // Method returning a List containing pointers to Ladder Cable Volumes
44285dfa 3931 /////////////////////////////////////////////////////////////
bf210566 3932 const Int_t kladdercablesegmentnumber = 2;
3933 /////////////////////////////////////////
3934 // LadderSegmentBBox Volume
3935 /////////////////////////////////////////
3936 TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
3937 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3938 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
3939 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3940 new TGeoBBox(laddercablesegmentbboxshapename[i],
3941 0.5*fgkSSDFlexWidth[0],
3942 0.5*fgkSSDLadderCableWidth,
3943 0.5*fgkSSDFlexHeight[i]);
3944 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3945 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3946 TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3947 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3948 laddercablesegmentbbox[i] =
3949 new TGeoVolume(laddercablesegmentbboxname[i],
3950 laddercablesegmentbboxshape[i],
3951 (i==0?fSSDAlTraceLadderCableMedium:
3952 fSSDKaptonLadderCableMedium));
3953 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3954 fColorPolyhamide);
3955 }
3956 TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
3957 laddercablesegmentbboxtrans[0] =
3958 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3959 0.5*fgkSSDFlexWidth[0],
3960 0.5*fgkSSDLadderCableWidth,
3961 0.5*fgkSSDFlexHeight[0]);
3962 laddercablesegmentbboxtrans[1] =
3963 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3964 0.5*fgkSSDFlexWidth[0],
3965 0.5*fgkSSDLadderCableWidth,
3966 fgkSSDFlexHeight[0]
3967 +0.5*fgkSSDFlexHeight[1]);
3968 TGeoVolume* laddercablesegmentbboxassembly =
3969 new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
3970 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3971 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3972 laddercablesegmentbboxtrans[i]);
3973/////////////////////////////////////////
3974// LadderSegmentArb8 Volume
3975/////////////////////////////////////////
3976 const Int_t kvertexnumber = 4;
3977 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3978 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3979 new TVector3*[kvertexnumber];
3980//Shape Vertex Positioning
3981 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3982 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3983 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3984 i*fgkSSDFlexHeight[0]);
3985 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3986 + fgkSSDFlexHeight[1]
3987 + i*fgkSSDFlexHeight[0]);
3988 laddercablesegmentvertexposition[i][3] =
3989 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3990 laddercablesegmentvertexposition[i][2]->Y());
3991 }
3992 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3993 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
3994 char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
3995 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
3996 TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3997 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3998 GetArbShape(laddercablesegmentvertexposition[i],
3999 laddercablesegmentwidth[i],
4000 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
4001 laddercablesegmentarbshapename[i]);
4002 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
4003 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
4004 TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
4005 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
4006 laddercablesegmentarb[i] =
4007 new TGeoVolume(laddercablesegmentarbname[i],
4008 laddercablesegmentarbshape[i],
4009 (i==0?fSSDAlTraceLadderCableMedium:
4010 fSSDKaptonLadderCableMedium));
4011 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
4012 fColorPolyhamide);
d7599219 4013}
bf210566 4014 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
4015 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
4016 90.,90,-90.);
4017 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
4018 0.,90.,0.);
4019 TGeoCombiTrans* laddercablesegmentarbcombitrans =
4020 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
4021 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
4022 + fgkSSDFlexWidth[0],0.,0.,
4023 new TGeoRotation((*laddercablesegmentarbrot[1])
4024 *(*laddercablesegmentarbrot[0])));
4025 TGeoVolume* laddercablesegmentarbassembly =
4026 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
4027 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
4028 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
4029 laddercablesegmentarbcombitrans);
4030/////////////////////////////////////////
4031// End Ladder Cable Volume
4032/////////////////////////////////////////
4033 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
4034 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
4035 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
4036 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
4037 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
4038 0.5*ssdendladdercablelength,
4039 0.5*fgkSSDLadderCableWidth,
4040 0.5*fgkSSDFlexHeight[i]);
4041 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
4042 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
4043 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
4044 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
4045 ladderendcablesegmentbbox[i] =
4046 new TGeoVolume(ladderendcablesegmentbboxname[i],
4047 ladderendcablesegmentbboxshape[i],
4048 (i==0?fSSDAlTraceLadderCableMedium:
4049 fSSDKaptonLadderCableMedium));
4050 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
4051 fColorPolyhamide);
4052 }
4053 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
4054 ladderendcablesegmentbboxtrans[0] =
4055 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
4056 0.5*ssdendladdercablelength,
4057 0.5*fgkSSDLadderCableWidth,
4058 0.5*fgkSSDFlexHeight[0]);
4059 ladderendcablesegmentbboxtrans[1] =
4060 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
4061 0.5*ssdendladdercablelength,
4062 0.5*fgkSSDLadderCableWidth,
4063 fgkSSDFlexHeight[0]
4064 +0.5*fgkSSDFlexHeight[1]);
4065 TGeoVolume* ladderendcablesegmentbboxassembly =
4066 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
4067 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
4068 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
4069 ladderendcablesegmentbboxtrans[i]);
4070/////////////////////////////////////////
4071 TList* laddercablesegmentlist = new TList();
4072 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
4073 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
4074 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
4075 return laddercablesegmentlist;
4076 }
4077/////////////////////////////////////////////////////////////////////////////////
4078TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 4079 /////////////////////////////////////////////////////////////
bf210566 4080 // Method generating Ladder Cable Volumes Assemblies
44285dfa 4081 /////////////////////////////////////////////////////////////
bf210566 4082 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
4083 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
4084 for(Int_t i=0; i<n; i++){
4085 TGeoTranslation* laddercabletrans = new TGeoTranslation(
4086 i*(fgkCarbonFiberJunctionWidth),
4087 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4088 i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4089 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
4090 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
d7599219 4091 }
bf210566 4092 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
4093 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4094 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
4095 (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
4096 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
4097 return laddercable;
4098}
4099/////////////////////////////////////////////////////////////////////////////////
4100TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
4101 /////////////////////////////////////////////////////////////
4102 // Method generating Ladder Cable Volumes Assembly
4103 /////////////////////////////////////////////////////////////
4104 TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
4105 char laddercabletransname[30];
4106 for(Int_t i=0; i<n; i++){
4107 sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
4108 laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
4109 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
d7599219 4110 }
bf210566 4111 return laddercableassembly;
4112}
4113/////////////////////////////////////////////////////////////////////////////////
4114TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
4115 /////////////////////////////////////////////////////////////
4116 // Method generating Ladder Cable List Assemblies
4117 /////////////////////////////////////////////////////////////
4118 const Int_t kladdercableassemblynumber = 2;
4119 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
4120 TGeoVolume* ladderCable[kladdercableassemblynumber];
4121 char laddercableassemblyname[30];
4122 TList* laddercableassemblylist = new TList();
4123 for(Int_t i=0; i<kladdercableassemblynumber; i++){
4124 sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
4125 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
4126 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
4127 new TGeoCombiTrans((n-1)
4128 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
4129 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
4130 0.,new TGeoRotation("",180,0.,0.)));
4131 laddercableassemblylist->Add(ladderCable[i]);
4132}
4133 return laddercableassemblylist;
4134}
4135///////////////////////////////////////////////////////////////////////////////
4136void AliITSv11GeometrySSD::SetLadderSegment(){
4137 /////////////////////////////////////////////////////////////
4138 // Method Generating Ladder Segment Array
4139 /////////////////////////////////////////////////////////////
4140 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
4141 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
4142 if(!fCreateMaterials) CreateMaterials();
4143 if(!fTransformationMatrices) CreateTransformationMatrices();
4144 if(!fBasicObjects) CreateBasicObjects();
4145 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
4146 // Placing Carbon Fiber Support
4147 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
4148 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4149 fcarbonfibersupportmatrix[j]);
4150 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4151 fcarbonfibersupportmatrix[j]);
d7599219 4152 }
bf210566 4153 // Placing Carbon Fiber Junction
4154 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++)
4155 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
4156 fcarbonfiberjunctionmatrix[j]);
4157 // Placing Carbon Fiber Lower Support
4158 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++)
4159 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
4160 fcarbonfiberlowersupportrans[j]);
4161 // Placing SSD Sensor Support
4162 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
4163 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
4164 fssdsensorsupport[1][i],
4165 j+1,fssdsensorsupportmatrix[j]);
4166 // Placing SSD Cooling Tube Support
4167 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
4168 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4169 fcoolingtubesupportmatrix[j]);
4170 // Placing SSD Cooling Tube
4171 for(Int_t j=0; j<2; j++)
4172 for(Int_t k=0; k<2; k++){
4173 fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]);
4174 fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]);
4175 }
4176 // Placing SSD Hybrid
4177 switch(i){
4178 case 0:
4179 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
4180 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4181 break;
4182 case 1:
4183 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
4184 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
4185 break;
4186 }
4187 // Placing Cooling Block System
4188 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
4189 // Placing SSD Flex
4190 for(Int_t j=0; j<fgkflexnumber; j++){
4191 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
4192 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
4193 }
4194 }
d7599219 4195}
bf210566 4196///////////////////////////////////////////////////////////////////////////////
4197void AliITSv11GeometrySSD::SetEndLadderSegment(){
4198 /////////////////////////////////////////////////////////////
4199 // Method Generating End Ladder
4200 /////////////////////////////////////////////////////////////
4201 // End Ladder Carbon Fiber Junction
4202 /////////////////////////////////////////////////////////////
4203 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
4204 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
4205 if(!fCreateMaterials) CreateMaterials();
4206 if(!fTransformationMatrices) CreateTransformationMatrices();
4207 if(!fBasicObjects) CreateBasicObjects();
4208 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
4209 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
4210 fendladdersegment[i]->AddNode(j==2 ?
4211 fendladdercarbonfiberjunction[i][1] :
4212 fendladdercarbonfiberjunction[i][0],
4213 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
4214 }
4215 /////////////////////////////////////////////////////////////
4216 // End Ladder Carbon Fiber Support
4217 /////////////////////////////////////////////////////////////
4218 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
4219 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
4220 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
4221 fendladdercarbonfibermatrix[i][j]);
4222 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
4223 fendladdercarbonfibermatrix[i][j]);
4224 }
4225 /////////////////////////////////////////////////////////////
4226 // End Ladder Mounting Block
4227 /////////////////////////////////////////////////////////////
9b0c60ab 4228 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4229 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
e21cdd03 4230 fendladdermountingblockcombitrans[i]);
9b0c60ab 4231 /////////////////////////////////////////////////////////////
e5bf64ae 4232 // End Ladder Mounting Block Clip
9b0c60ab 4233 /////////////////////////////////////////////////////////////
4234 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
4235 for(Int_t j=0; j<2; j++)
e21cdd03 4236 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
4237 fendladdermountingblockclipmatrix[i][j]);
bf210566 4238 /////////////////////////////////////////////////////////////
4239 // End Ladder Lower Supports
44285dfa 4240 /////////////////////////////////////////////////////////////
bf210566 4241 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
e21cdd03 4242 fendladderlowersupptrans[0]);
bf210566 4243 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
e21cdd03 4244 fendladderlowersupptrans[1]);
bf210566 4245 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
e21cdd03 4246 fendladderlowersupptrans[2]);
9b0c60ab 4247 /////////////////////////////////////////////////////////////
4248 // End Ladder Cooling Tube Support
4249 /////////////////////////////////////////////////////////////
4250 for(Int_t i=0; i<2; i++)
4251 for(Int_t j=0; j<(i==0?4:2); j++)
e21cdd03 4252 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
4253 fendladdercoolingtubesupportmatrix[i][j]);
9b0c60ab 4254 /////////////////////////////////////////////////////////////
4255 // End Ladder Cooling Tube Support
4256 /////////////////////////////////////////////////////////////
4257 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
4258 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
4259 fendladdersegment[0]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[0][2]);
4260 fendladdersegment[0]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[0][3]);
4261 fendladdersegment[0]->AddNode(fendladdercoolingtube[2],1,fendladdercoolingtubematrix[0][4]);
4262 fendladdersegment[0]->AddNode(fendladdercoolingtube[2],2,fendladdercoolingtubematrix[0][5]);
4263 fendladdersegment[1]->AddNode(fendladdercoolingtube[3],1,fendladdercoolingtubematrix[1][0]);
4264 fendladdersegment[1]->AddNode(fendladdercoolingtube[3],2,fendladdercoolingtubematrix[1][1]);
4265 fendladdersegment[1]->AddNode(fendladdercoolingtube[4],1,fendladdercoolingtubematrix[1][2]);
4266 fendladdersegment[1]->AddNode(fendladdercoolingtube[4],2,fendladdercoolingtubematrix[1][3]);
bf210566 4267}
4268///////////////////////////////////////////////////////////////////////////////
4269void AliITSv11GeometrySSD::SetLadder(){
4270 /////////////////////////////////////////////////////////////
4271 // Method Generating Ladder of Layer 5 and 6
44285dfa 4272 /////////////////////////////////////////////////////////////
bf210566 4273 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
4274 fgkSSDLay6SensorsNumber};
4275 /////////////////////////////////////////////////////////////////////////////
4276 /// Generating Ladder Mother Volume Containing Ladder
4277 /////////////////////////////////////////////////////////////////////////////
4278 TGeoXtru* laddershape[fgkladdernumber];
4279 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
4280 const Int_t kmothervertexnumber = 8;
4281 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
4282 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
4283 ///////////////////////
4284 // Setting the vertices
4285 ///////////////////////
4286 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
4287 * (fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]);
4288 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
e21cdd03 4289 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
4290 - fgkSSDModuleVerticalDisalignment;
bf210566 4291 xmothervertex[0][1] = xmothervertex[0][0];
4292 ymothervertex[0][1] = 0.0;
4293 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
4294 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
4295 ymothervertex[0][2] = ymothervertex[0][1];
4296 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
4297 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
4298 xmothervertex[0][4] = -xmothervertex[0][3];
4299 ymothervertex[0][4] = ymothervertex[0][3];
4300 xmothervertex[0][5] = -xmothervertex[0][2];
4301 ymothervertex[0][5] = ymothervertex[0][2];
4302 xmothervertex[0][6] = -xmothervertex[0][1];
4303 ymothervertex[0][6] = ymothervertex[0][1];
4304 xmothervertex[0][7] = -xmothervertex[0][0];
4305 ymothervertex[0][7] = ymothervertex[0][0];
4306 for(Int_t i=0; i<kmothervertexnumber; i++){
4307 xmothervertex[1][i] = xmothervertex[0][i];
4308 ymothervertex[1][i] = ymothervertex[0][i];
4309 }
4310 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4311 for(Int_t i=0; i<fgkladdernumber; i++){
4312 laddershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
4313 ymothervertex[i]);
4314 laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4315 laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4316 +fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4317 fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir);
9b0c60ab 4318 fladder[i]->SetLineColor(4);
bf210566 4319 }
4320///////////////////////////////////////////////////////////////////////////
4321 if(!fCreateMaterials) CreateMaterials();
4322 if(!fTransformationMatrices) CreateTransformationMatrices();
4323 if(!fBasicObjects) CreateBasicObjects();
4324 SetLadderSegment();
4325 SetEndLadderSegment();
4326 for(Int_t i=0; i<fgkladdernumber; i++){
4327 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4328 //////////////////////////
4329 /// Placing Ladder Segment
4330 //////////////////////////
4331 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4332 fladdersegment[i==0 ? 1 : 0],
4333 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4334 //////////////////////////
4335 /// Placing SSD Sensor
4336 //////////////////////////
4337 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4338 fssdsensormatrix[i][j]);
4339 }
4340 ///////////////////////////////
4341 /// Placing End Ladder Segment
4342 ///////////////////////////////
4343 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
4344 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4345 }
d7599219 4346/////////////////////////////////////////////////////////////////////////////
4347/// Placing Ladder Cables
4348/////////////////////////////////////////////////////////////////////////////
bf210566 4349 Int_t sidecablenumber[2][2];
4350 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4351 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4352 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4353 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4354 Double_t carbonfibertomoduleposition[3];
4355 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4356 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4357 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4358 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4359 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4360 - fgkSSDSensorCenterSupportThickness[0]);
4361 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4362 + 0.5*fgkCoolingTubeSupportHeight
4363 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4364 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4365 Double_t ssdendladdercablelength[4];
4366 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4367 + fgkSSDSensorLength
4368 - fgkSSDModuleStiffenerPosition[1]
4369 - fgkSSDStiffenerWidth
4370 - fgkSSDFlexWidth[0]
bf210566 4371 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4372 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4373 + fgkSSDModuleStiffenerPosition[1]
4374 + fgkSSDStiffenerWidth
bf210566 4375 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4376 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4377 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4378 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4379 - kendladdercablecorrection;
44285dfa 4380 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4381 + carbonfibertomoduleposition[1]
d7599219 4382 - fgkSSDModuleStiffenerPosition[1]
4383 - fgkSSDStiffenerWidth)
bf210566 4384 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
44285dfa 4385 TList* laddercableassemblylist[4];
4386 const Int_t kendladdercablesnumber = 4;
bf210566 4387 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4388 for(Int_t j=0; j<kendladdercablesnumber; j++){
4389 laddercableassemblylist[j] =
4390 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4391 ssdendladdercablelength[j]);
4392 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4393 j<2?1:2,fladdercablematrix[i][j]);
4394 }
bf210566 4395}
4396////////////////////////////////////////////////////////////////////////////////
4397void AliITSv11GeometrySSD::SetLayer(){
d7599219 4398////////////////////////////////////////////////////////////////////////////////
bf210566 4399 // Creating Ladder of Layer 5 and Layer 6
4400 /////////////////////////////////////////////////////////////
4401 if(!fCreateMaterials) CreateMaterials();
4402 if(!fTransformationMatrices) CreateTransformationMatrices();
4403 if(!fBasicObjects) CreateBasicObjects();
4404 SetLadder(); // Generating the ladder of Layer5 and Layer6
4405 const Int_t kssdlayladdernumber[fgklayernumber] =
4406 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4407 /////////////////////////////////////////////////////////////
4408 // Generating mother volumes for Layer5 and Layer6
4409 /////////////////////////////////////////////////////////////
e5bf64ae 4410 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4411 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
bf210566 4412 Int_t *ladderindex[fgklayernumber];
4413 Int_t index[fgklayernumber] = {8,9};
4414 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4415 for(Int_t i=0; i<fgklayernumber; i++)
4416 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4417 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4418 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4419 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4420 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4421 }
44285dfa 4422 /////////////////////////////////////////////////////////////
bf210566 4423 // Deallocating memory
4424 /////////////////////////////////////////////////////////////
9b0c60ab 4425 for(Int_t i=0; i<fgklayernumber; i++) delete ladderindex[i];
d7599219 4426}
4427////////////////////////////////////////////////////////////////////////////////
4428void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4429 /////////////////////////////////////////////////////////////
4430 // Insert the layer 5 in the mother volume.
4431 /////////////////////////////////////////////////////////////
4432 if (! moth) {
4433 printf("Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!\n");
4434 return;
4435 };
bf210566 4436 if(!fSSDLayer5) SetLayer();
4437 fMotherVol = moth;
4438 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4439 + fgkLay5CenterITSPosition);
4440 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4441 }
d7599219 4442////////////////////////////////////////////////////////////////////////////////
4443void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4444 /////////////////////////////////////////////////////////////
4445 // Insert the layer 6 in the mother volume.
4446 /////////////////////////////////////////////////////////////
4447 if (! moth) {
4448 printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
4449 return;
4450 };
bf210566 4451 if(!fSSDLayer6) SetLayer();
4452 fMotherVol = moth;
4453 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4454 + fgkLay6CenterITSPosition);
4455 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4456 }
bf210566 4457 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4458 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4459 /////////////////////////////////////////////////////////////
4460 // Method generating the Arc structure of Ladder Support
4461 /////////////////////////////////////////////////////////////
4462 const Int_t kssdlayladdernumber[fgklayernumber] =
4463 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4464 Double_t mountingsupportedge[fgklayernumber];
4465 Double_t mountingblockratio[fgklayernumber];
4466 Double_t theta[fgklayernumber];
4467 Double_t phi[fgklayernumber];
4468 Double_t psi0[fgklayernumber];
4469 Double_t deltapsi[fgklayernumber];
4470 TVector3* mountingsupportedgevector[fgklayernumber];
4471 for(Int_t i=0; i<fgklayernumber; i++){
4472 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4473 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4474 *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4475 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4476 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4477 / kssdlayladdernumber[i])));
4478 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4479 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4480 mountingsupportedgevector[i] = new TVector3();
4481 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4482 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(1.
4483 -TMath::Power(mountingsupportedgevector[i]->X()
4484 / fgkMountingBlockSupportRadius[i],2)));
4485 psi0[i] = 0.5*TMath::Pi()-phi[i];
4486 deltapsi[i] = (theta[i]+phi[i])/nedges;
4487 }
4488 TVector3** vertex[fgklayernumber];
4489 TList* vertexlist[fgklayernumber];
4490 Int_t indexedge[fgklayernumber] = {0,0};
4491 for(Int_t i=0; i<fgklayernumber; i++){
4492 vertex[i] = new TVector3*[nedges+1];
4493 vertexlist[i] = new TList();
4494 }
4495 for(Int_t i=0; i<fgklayernumber; i++){
4496 for(Int_t j=0; j<nedges+1; j++){
4497 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4498 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4499 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4500 vertexlist[i]->Add(vertex[i][j]);
4501 }
4502 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4503 }
4504 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4505 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4506 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4507 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4508 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4509 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4510 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4511 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4512 for(Int_t i=0; i<fgklayernumber; i++){
4513 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4514 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4515 xcentervertex[i] = new Double_t[indexedge[i]+3];
4516 ycentervertex[i] = new Double_t[indexedge[i]+3];
4517 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4518 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4519 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4520 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4521 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4522 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4523 ((TVector3*)vertexlist[i]->At(j))->X();
4524 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4525 ((TVector3*)vertexlist[i]->At(j))->Y();
4526 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4527 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4528 if(j<indexedge[i]+1){
4529 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4530 ((TVector3*)vertexlist[i]->At(j))->X();
4531 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4532 ((TVector3*)vertexlist[i]->At(j))->Y();
4533 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4534 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4535 }
4536 }
4537 xsidevertex[i][1] = xsidevertex[i][0];
4538 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4539 xsidevertex[i][2] = xsidevertex[i][3];
4540 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4541 xcentervertex[i][1] = xcentervertex[i][0];
4542 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4543 xcentervertex[i][2] = xcentervertex[i][3];
4544 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4545 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4546 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4547 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4548 ycenterlowervertex[i][0] = ysidevertex[i][0];
4549 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4550 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4551 }
4552 /////////////////////////////////////////////////////////////
4553 // Building the Arc Structure of Ladder Supports
4554 /////////////////////////////////////////////////////////////
4555 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4556 TGeoXtru* centermountingsupportshape[fgklayernumber];
4557 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4558 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4559 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4560 TGeoVolume* centermountingblocksupport[fgklayernumber];
4561 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4562 TGeoVolume* centerladdersupportpiece[fgklayernumber];
4563 char sidemountingblockname[40];
4564 char centermountingblockname[40];
4565 char sideladdersupportpiecename[40];
4566 char centerladdersupportpiecename[40];
4567 for(Int_t i=0; i<fgklayernumber; i++){
4568 sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4569 sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4570 sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4571 sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4572 sidemountingblocksupportshape[i] = new TGeoXtru(2);
4573 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4574 xsidevertex[i],ysidevertex[i]);
4575 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4576 -fgkMountingBlockSupportWidth[0]);
4577 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4578 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4579 sidemountingblocksupportshape[i],
4580 fSSDAlCoolBlockMedium);
4581 sidemountingblocksupport[i]->SetLineColor(9);
4582 centermountingsupportshape[i] = new TGeoXtru(2);
4583 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4584 xcentervertex[i],ycentervertex[i]);
4585 centermountingsupportshape[i]->DefineSection(0,0.);
4586 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4587 -fgkMountingBlockSupportWidth[0]);
4588 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4589 centermountingsupportshape[i],
4590 fSSDAlCoolBlockMedium);
4591 centermountingblocksupport[i]->SetLineColor(9);
4592 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4593 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4594 xsidelowervertex[i],ysidelowervertex[i]);
4595 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4596 -fgkMountingBlockSupportWidth[0]);
4597 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4598 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4599 sideladdersupportpieceshape[i],
e21cdd03 4600 fSSDCarbonFiberMedium);
9b0c60ab 4601 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4602 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4603 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4604 xcenterlowervertex[i],ycenterlowervertex[i]);
4605 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4606 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4607 -fgkMountingBlockSupportWidth[0]);
4608 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4609 centerladdersupportpieceshape[i],
e21cdd03 4610 fSSDCarbonFiberMedium);
9b0c60ab 4611 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4612 }
4613 /////////////////////////////////////////////////////////////
4614 // Building the Up Structure of Ladder Supports
4615 /////////////////////////////////////////////////////////////
4616 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4617 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4618 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4619 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4620 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4621 //////////////////////////////////////////////////////////
4622 // Setting the volume for TGeoXtru Mounting Block Piece
4623 //////////////////////////////////////////////////////////
4624 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4625 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4626 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4627 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4628 TGeoVolume* mountingblockpieceup[fgklayernumber];
4629 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4630 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4631 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4632 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
4633 char mountingblockpiecedownname[34];
4634 char mountingblockpieceupname[34];
4635 for(Int_t i=0; i<fgklayernumber; i++){
4636 ///////////////////////////
4637 // Mounting Block Down Vertex
4638 ///////////////////////////
4639 mountingblockpiecedownshape[i] = new TGeoXtru(2);
4640 sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4641 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4642 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4643 + fgkMountingBlockSupportDownHeight;
4644 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4645 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4646 + fgkSSDMountingBlockHeight[1]
4647 - 0.5*fgkCoolingTubeSupportHeight
e21cdd03 4648 - fgkSSDModuleCoolingBlockToSensor
4649 - fgkSSDModuleVerticalDisalignment;
9b0c60ab 4650 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4651 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4652 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4653 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4654 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4655 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4656 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4657 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4658 + fgkSSDMountingBlockHeight[2]
4659 - fgkSSDMountingBlockHeight[0];
4660 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4661 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4662 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4663 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4664 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4665 mountingblockpiecedownyvertex[i]);
4666 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4667 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4668 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
e21cdd03 4669 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
9b0c60ab 4670 mountingblockpiecedown[i]->SetLineColor(fColorG10);
4671 ///////////////////////////
4672 // Mounting Block Up Vertex
4673 ///////////////////////////
4674 mountingblockpieceupshape[i] = new TGeoXtru(2);
4675 sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4676 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4677 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
4678 + fgkMountingBlockSupportUpHeight[i];
4679 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4680 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4681 + fgkSSDMountingBlockHeight[1]
4682 - 0.5*fgkCoolingTubeSupportHeight
e21cdd03 4683 - fgkSSDModuleCoolingBlockToSensor
4684 - fgkSSDModuleVerticalDisalignment;
9b0c60ab 4685 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4686 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4687 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4688 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4689 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4690 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4691 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4692 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4693 + fgkSSDMountingBlockHeight[2]
4694 - fgkSSDMountingBlockHeight[0];
4695 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4696 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4697 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4698 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
4699 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4700 mountingblockpieceupyvertex[i]);
4701 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4702 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4703 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
e21cdd03 4704 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
9b0c60ab 4705 mountingblockpieceup[i]->SetLineColor(fColorG10);
4706 }
4707 ///////////////////////////////////////////////////////////////////
4708 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4709 ///////////////////////////////////////////////////////////////////
4710 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4711 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4712 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4713 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4714 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4715 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4716 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4717 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
4718 char mountingblocksupportrapezoidowname[40];
4719 char mountingblocksupportrapezoidupname[40];
4720 Double_t scalefactor = 3./4.;
4721 for(Int_t i=0; i<fgklayernumber; i++){
4722 ////////////////////////////////////////////
4723 // Mounting Block Support Down Trapezoid Vertex
4724 ////////////////////////////////////////////
4725 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4726 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4727 - mountingsupportedge[i];
4728 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4729 mountingblocksupportrapezoidownxvertex[i][1] =
4730 mountingblocksupportrapezoidownxvertex[i][0];
4731 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4732 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4733 - mountingblockpiecedownyvertex[i][0]);
4734 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4735 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4736 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4737 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4738 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4739 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
4740 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4741 mountingblocksupportrapezoidownyvertex[i]);
4742 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4743 -fgkMountingBlockSupportWidth[0]);
4744 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4745 sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4746 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
e21cdd03 4747 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4748 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4749 ////////////////////////////////////////////
4750 // Mounting Block Support Up Trapezoid Vertex
4751 ////////////////////////////////////////////
4752 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4753 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4754 - mountingsupportedge[i];
4755 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4756 mountingblocksupportrapezoidupxvertex[i][1] =
4757 mountingblocksupportrapezoidupxvertex[i][0];
4758 mountingblocksupportrapezoidupyvertex[i][1] =
4759 mountingblockpieceupyvertex[i][0]
4760 + scalefactor*(mountingblockpieceupyvertex[i][1]
4761 - mountingblockpieceupyvertex[i][0]);
4762 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4763 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4764 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4765 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4766 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4767 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
4768 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4769 mountingblocksupportrapezoidupyvertex[i]);
4770 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4771 -fgkMountingBlockSupportWidth[0]);
4772 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4773 sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4774 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
e21cdd03 4775 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4776 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4777 }
4778 ///////////////////////////////////////////////////////////////////
4779 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4780 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4781 Double_t boxoriginup[fgklayernumber][2][3];
4782 Double_t boxorigindown[fgklayernumber][2][3];
4783 char mountingblocksupportboxdownname[34];
4784 char mountingblocksupportboxupname[34];
4785 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4786 mountingblocksupportrot->SetAngles(90.,180.,-90);
4787 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4788 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4789 TGeoHMatrix* laddersupportmatrix[2];
4790 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4791 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4792 /////////////////////////////////////////////////////////////
4793 // Creating Mother Volume for Containment
4794 /////////////////////////////////////////////////////////////
4795 Double_t *xmothervertex[fgklayernumber];
4796 Double_t *ymothervertex[fgklayernumber];
4797 for(Int_t i=0; i<fgklayernumber; i++){
4798 xmothervertex[i] = new Double_t[8];
4799 ymothervertex[i] = new Double_t[8];
4800 }
4801 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4802 TGeoVolume* downmotherladdersupport[fgklayernumber];
4803 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
4804 TGeoVolume* upmotherladdersupport[fgklayernumber];
4805 char upmotheladdersupportname[30];
4806 char downmotheladdersupportname[30];
4807 for(Int_t i=0; i<fgklayernumber; i++){
4808 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4809 - mountingsupportedge[i];
4810 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4811 xmothervertex[i][1] = xmothervertex[i][0];
4812 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4813 + fgkMountingBlockSupportWidth[0];
4814 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4815 ymothervertex[i][2] = ymothervertex[i][1];
4816 xmothervertex[i][3] = xmothervertex[i][2];
4817 ymothervertex[i][3] = -ymothervertex[i][0];
4818 xmothervertex[i][4] = -xmothervertex[i][0];
4819 ymothervertex[i][4] = ymothervertex[i][3];
4820 xmothervertex[i][5] = xmothervertex[i][4];
4821 ymothervertex[i][5] = -ymothervertex[i][1];
4822 xmothervertex[i][6] = -xmothervertex[i][2];
4823 ymothervertex[i][6] = ymothervertex[i][5];
4824 xmothervertex[i][7] = xmothervertex[i][6];
4825 ymothervertex[i][7] = ymothervertex[i][0];
4826 sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4827 sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
4828 downmotherladdersupportshape[i] = new TGeoXtru(2);
4829 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4830 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4831 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4832 + fgkMountingBlockSupportDownHeight
4833 + fgkSSDMountingBlockHeight[1]
4834 - 0.5*fgkCoolingTubeSupportHeight
e21cdd03 4835 - fgkSSDModuleCoolingBlockToSensor
606d8cca 4836 - 2.*fgkSSDModuleVerticalDisalignment);
9b0c60ab 4837 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4838 downmotherladdersupportshape[i],fSSDAir);
4839 upmotherladdersupportshape[i] = new TGeoXtru(2);
4840 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4841 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4842 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4843 + fgkMountingBlockSupportUpHeight[i]
4844 + fgkSSDMountingBlockHeight[1]
4845 - 0.5*fgkCoolingTubeSupportHeight
e21cdd03 4846 - fgkSSDModuleCoolingBlockToSensor
606d8cca 4847 - 2.*fgkSSDModuleVerticalDisalignment);
9b0c60ab 4848 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4849 upmotherladdersupportshape[i],fSSDAir);
4850 }
4851 for(Int_t i=0; i<fgklayernumber; i++){
4852 /////////////////////////
4853 // Setting the box origin
4854 /////////////////////////
4855 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4856 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
4857 + 0.5*fgkMountingBlockSupportDownHeight;
4858 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4859 - 0.5*fgkMountingBlockSupportWidth[0];
4860
4861 boxorigindown[i][1][0] = 0.0;
4862 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4863 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4864 - fgkMountingBlockSupportWidth[0]);
4865
4866 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4867 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
4868 + 0.5*fgkMountingBlockSupportUpHeight[i];
4869 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4870 - 0.5*fgkMountingBlockSupportWidth[0];
4871
4872 boxoriginup[i][1][0] = 0.0;
4873 boxoriginup[i][1][1] = fgkMountingBlockSupportRadius[i]
4874 + 0.5*fgkMountingBlockSupportUpHeight[i];
4875 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4876 - fgkMountingBlockSupportWidth[0]);
4877
4878 /////////////////////////
4879 // Setting the boxes
4880 /////////////////////////
4881 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4882 + fgkSSDMountingBlockLength[0]),
4883 0.5*fgkMountingBlockSupportDownHeight,
4884 0.5*fgkMountingBlockSupportWidth[0],
4885 boxorigindown[i][0]);
4886 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4887 0.5*fgkMountingBlockSupportDownHeight,
4888 0.5*(fgkMountingBlockSupportWidth[1]
4889 - fgkMountingBlockSupportWidth[0]),
4890 boxorigindown[i][1]);
4891
4892 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4893 + fgkSSDMountingBlockLength[0]),
4894 0.5*fgkMountingBlockSupportUpHeight[i],
4895 0.5*fgkMountingBlockSupportWidth[0],
4896 boxoriginup[i][0]);
4897
4898 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4899 0.5*fgkMountingBlockSupportUpHeight[i],
4900 0.5*(fgkMountingBlockSupportWidth[1]
4901 - fgkMountingBlockSupportWidth[0]),
4902 boxoriginup[i][1]);
4903 ///////////////////////////////////////
4904 // Adding the Volumes to Mother Volume
4905 ///////////////////////////////////////
4906 for(Int_t j=0; j<2; j++){
4907 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4908 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4909 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4910 mountingblocksupportboxdownshape[i][j],
e21cdd03 4911 fSSDCarbonFiberMedium);
9b0c60ab 4912 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4913 mountingblocksupportboxupshape[i][j],
e21cdd03 4914 fSSDCarbonFiberMedium);
9b0c60ab 4915 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4916 mountingblocksupportboxup[i][j]->SetLineColor(9);
4917 for(Int_t k=0; k<2; k++){
4918 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
4919 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
4920 }
4921 }
4922 for(Int_t k=0; k<2; k++){
4923 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4924 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4925 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4926 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4927 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
4928 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4929 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4930 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4931 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4932 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4933 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4934 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
4935 }
4936 }
4937 TList* laddersupportlist = new TList();
4938 laddersupportlist->Add(downmotherladdersupport[0]);
4939 laddersupportlist->Add(upmotherladdersupport[0]);
4940 laddersupportlist->Add(downmotherladdersupport[1]);
4941 laddersupportlist->Add(upmotherladdersupport[1]);
4942 /////////////////////////////////////////////////////////////
4943 // Deallocating memory
4944 /////////////////////////////////////////////////////////////
4945 for(Int_t i=0; i<fgklayernumber; i++){
4946 for(Int_t j=0; j<nedges+1; j++)
4947 delete vertex[i][j];
4948 delete mountingsupportedgevector[i];
4949 delete [] vertex[i];
4950 delete vertexlist[i];
4951 delete [] xsidevertex[i];
4952 delete [] ysidevertex[i];
4953 delete [] xcentervertex[i];
4954 delete [] ycentervertex[i];
4955 delete [] xsidelowervertex[i];
4956 delete [] ysidelowervertex[i];
4957 delete [] xcenterlowervertex[i];
4958 delete [] ycenterlowervertex[i];
4959 }
4960 delete xsidevertex;
4961 delete ysidevertex;
4962 delete xcentervertex;
4963 delete ycentervertex;
4964 delete xsidelowervertex;
4965 delete ysidelowervertex;
4966 delete xcenterlowervertex;
4967 delete ycenterlowervertex;
4968 delete globalrefladdersupportrot;
4969 delete mountingblocksupportrot;
4970 /////////////////////
4971 return laddersupportlist;
4972}
4973 ////////////////////////////////////////////////////////////////////////////////
4974void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4975//////////////////////////////////////////
4976// Method Generating Ladder Support Ring
4977//////////////////////////////////////////
4978 if(!fCreateMaterials) CreateMaterials();
4979 if(!fTransformationMatrices) CreateTransformationMatrices();
4980 if(!fBasicObjects) CreateBasicObjects();
4981 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4982 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4983 const Int_t kssdlayladdernumber[fgklayernumber] =
4984 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4985 Double_t mountingsupportedge[fgklayernumber];
4986 Double_t mountingblockratio[fgklayernumber];
4987 Double_t theta[fgklayernumber];
4988 Double_t phi[fgklayernumber];
4989 for(Int_t i=0; i<fgklayernumber; i++){
4990 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4991 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
4992 *(TMath::Sqrt(4.0-TMath::Power(mountingblockratio[i],2))
4993 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4994 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4995 / kssdlayladdernumber[i])));
4996 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4997 / fgkMountingBlockSupportRadius[i]);
4998 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4999 }
5000 TGeoRotation* globalrot = new TGeoRotation();
5001 globalrot->SetAngles(0.,-90.,0.);
5002 TGeoRotation** laddersupportrot[fgklayernumber];
5003 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
5004 for(Int_t i=0; i<fgklayernumber; i++){
5005 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
5006 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
5007 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
5008 laddersupportrot[i][j] = new TGeoRotation();
5009 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
5010 switch(i){
5011 case 0: //Ladder of Layer5
5012 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
5013 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
5014 laddersupportmatrix[i][j]);
5015 break;
5016 case 1: //Ladder of Layer6
5017 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
5018 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
5019 laddersupportmatrix[i][j]);
5020 break;
5021 }
5022 }
5023 }
5024 /////////////////////////////////////////////////////////////
5025 // Creating Lower Ladder Support
5026 /////////////////////////////////////////////////////////////
5027 TVector3** ringsupportvertex[fgklayernumber];
5028 Double_t angle = 360./nedges;
5029 for(Int_t i=0; i<fgklayernumber; i++){
5030 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
5031 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
5032 * TMath::Cos(theta[i]));
5033 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
5034 - mountingsupportedge[i],
5035 ringsupportvertex[i][0]->Y());
5036 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
5037 ringsupportvertex[i][1]->Y());
5038 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
5039 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
5040 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
5041 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
5042 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
5043 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
5044 }
5045 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
5046 for(Int_t j=0; j<nedges+1; j++){
5047 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
5048 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*CosD(90.0-j*angle),
5049 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeigth)*SinD(90.0-j*angle));
5050 }
5051 }
5052 Double_t **xmothervertex = new Double_t*[fgklayernumber];
5053 Double_t **ymothervertex = new Double_t*[fgklayernumber];
5054 for(Int_t i=0; i<fgklayernumber; i++){
5055 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5056 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
5057 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
5058 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
5059 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
5060 }
5061 }
5062 char lowerladdersupportname[30];
5063 TGeoXtru* lowerladdersupportshape[fgklayernumber];
5064 TGeoVolume* lowerladdersupport[fgklayernumber];
5065 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5066 lowerladdersupportrot->SetAngles(90.,180.,-90);
5067 for(Int_t i=0; i<fgklayernumber; i++){
5068 lowerladdersupportshape[i] = new TGeoXtru(2);
5069 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
5070 xmothervertex[i],ymothervertex[i]);
5071 lowerladdersupportshape[i]->DefineSection(0,0.);
5072 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
5073 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
5074 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
5075 lowerladdersupportshape[i],fSSDSupportRingAl);
5076 lowerladdersupport[i]->SetLineColor(fColorAl);
5077 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
5078 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
5079 }
5080 /////////////////////////////////////////////////////////////
5081 // Deallocating memory
5082 /////////////////////////////////////////////////////////////
5083 for(Int_t i=0; i<fgklayernumber; i++){
5084 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
5085 delete ringsupportvertex[i][j];
5086 delete [] ringsupportvertex[i];
5087 }
5088 for(Int_t i=0; i<fgklayernumber; i++){
5089 delete [] xmothervertex[i];
5090 delete [] ymothervertex[i];
5091 }
5092 delete xmothervertex;
5093 delete ymothervertex;
5094 delete globalrot;
5095 for(Int_t i=0; i<fgklayernumber; i++){
5096 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
5097 delete laddersupportrot[i][j];
5098 delete [] laddersupportrot[i];
5099 }
5100 }
5101 ////////////////////////////////////////////////////////////////////////////////
5102 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
5103 /////////////////////////////////////////////////////////////
5104 // Method generating Endcap CoverPlate
5105 /////////////////////////////////////////////////////////////
5106 // Holes Definition
5107 ///////////////////
5108 Int_t nendcapcoverplateholedges = 30;
5109 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
5110 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
5111 0.5*fgkEndCapCoverPlateThickness};
5112 TGeoXtru* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
5113 nendcapcoverplateholedges,holesection);
5114 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 5115 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 5116 endcapcoverplatesmallhole->SetLineColor(6);
5117 TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
5118 nendcapcoverplateholedges,holesection);
5119 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 5120 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 5121 endcapcoverplatebighole->SetLineColor(6);
5122 //////////////////////////
5123 // Screw Piece Definition
5124 //////////////////////////
5125 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
5126 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
5127 CosD(0.5*smallscrewangle),
5128 0.5*fgkEndCapCoverPlateThickness);
5129 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
5130 endcapsmallscrewpieceshape,
5131 fSSDCoolingTubePhynox);
5132 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
5133 ///////////////////
5134 // Box Definition
5135 ///////////////////
5136 TGeoBBox* endcapcoverplateboxshape[4];
5137 TGeoVolume* endcapcoverplatebox[4];
5138 Double_t boxorigin[5][3];
5139 boxorigin[0][0] = 0.;
5140 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
5141 boxorigin[0][2] = 0.;
5142
5143 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
5144 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
5145 boxorigin[1][2] = 0.;
5146
5147 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
5148 + fgkEndCapCoverPlateSmallHoleSeparation[1];
5149 boxorigin[2][1] = boxorigin[1][1];
5150 boxorigin[2][2] = 0.;
5151
5152 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
5153 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
5154 boxorigin[3][1] = boxorigin[1][1];
5155 boxorigin[3][2] = 0.;
5156
5157 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5158 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5159 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
5160 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5161
5162 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5163 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5164 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5165 + fgkEndCapCoverPlateSmallHoleRadius,
5166 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5167
5168 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5169 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5170 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5171 + fgkEndCapCoverPlateSmallHoleRadius,
5172 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5173
5174 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5175 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5176 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5177 + fgkEndCapCoverPlateSmallHoleRadius,
5178 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5179
5180 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 5181 fSSDAlCoolBlockMedium);
9b0c60ab 5182 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 5183 fSSDAlCoolBlockMedium);
9b0c60ab 5184 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 5185 fSSDAlCoolBlockMedium);
9b0c60ab 5186 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 5187 fSSDAlCoolBlockMedium);
9b0c60ab 5188 endcapcoverplatebox[0]->SetLineColor(6);
5189 endcapcoverplatebox[1]->SetLineColor(6);
5190 endcapcoverplatebox[2]->SetLineColor(6);
5191 endcapcoverplatebox[3]->SetLineColor(6);
5192 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5193 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5194 fgkEndCapCoverPlateSmallHoleRadius,
5195 0.5*fgkEndCapCoverPlateThickness,
5196 endcapfillingboxorigin);
5197 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 5198 fSSDAlCoolBlockMedium);
9b0c60ab 5199 endcapfillingbox->SetLineColor(6);
5200 ////////////////////////////
5201 // Contour Xtru Definition
5202 ////////////////////////////
5203 const Int_t kcontourvertexnumber = 10;
5204 Double_t xcontourvertex[kcontourvertexnumber];
5205 Double_t ycontourvertex[kcontourvertexnumber];
5206 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5207 xcontourvertex[1] = xcontourvertex[0];
5208 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5209 xcontourvertex[3] = xcontourvertex[2];
5210 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5211 xcontourvertex[5] = xcontourvertex[4];
5212 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5213 xcontourvertex[7] = xcontourvertex[6];
5214 xcontourvertex[8] = xcontourvertex[4];
5215 xcontourvertex[9] = xcontourvertex[8];
5216 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5217 - (kendcapcoverplatesmallholenumber[1]-1)
5218 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5219 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5220 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5221 ycontourvertex[2] = ycontourvertex[1];
5222 ycontourvertex[3] = ycontourvertex[0];
5223 ycontourvertex[4] = ycontourvertex[3];
5224 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5225 ycontourvertex[6] = ycontourvertex[5];
5226 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5227 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5228 + fgkEndCapCoverPlateSmallHoleRadius;
5229 ycontourvertex[8] = ycontourvertex[7];
5230 ycontourvertex[9] = ycontourvertex[0];
5231 TGeoXtru* contourshape = new TGeoXtru(2);
5232 contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex);
5233 contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5234 contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
e21cdd03 5235 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5236 fSSDAlCoolBlockMedium);
9b0c60ab 5237 contour->SetLineColor(6);
5238 /////////////////////////////
5239 // Hole Contour Xtru Definition
5240 ////////////////////////////
5241 const Int_t kholecontourvertexnumber = 10;
5242 Double_t xholecontourvertex[2][kcontourvertexnumber];
5243 Double_t yholecontourvertex[2][kcontourvertexnumber];
5244 xholecontourvertex[0][0] = xcontourvertex[0];
5245 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5246 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5247 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5248 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5249 + 0.5*(fgkEndCapCoverPlateLength[2]
5250 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5251 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5252 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5253 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5254 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5255 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5256 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5257
5258 yholecontourvertex[0][0] = ycontourvertex[1];
5259 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5260 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5261 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5262 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5263 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5264 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5265 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5266 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5267 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5268 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5269
5270 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5271 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5272 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5273 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5274 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5275 + 0.5*(fgkEndCapCoverPlateLength[2]
5276 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5277 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5278 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5279 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5280 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5281 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5282 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5283
5284 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5285 - fgkEndCapCoverPlateWidth[0]);
5286 yholecontourvertex[1][1] = ycontourvertex[0];
5287 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5288 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5289 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5290 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5291 - fgkEndCapCoverPlateWidth[0]
5292 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5293 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5294 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5295 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5296 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5297
5298 TGeoXtru* holecontourshape[2];
5299 holecontourshape[0] = new TGeoXtru(2);
5300 holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0],
5301 yholecontourvertex[0]);
5302 holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5303 holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5304
5305 holecontourshape[1] = new TGeoXtru(2);
5306 holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1],
5307 yholecontourvertex[1]);
5308 holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5309 holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5310
5311 TGeoVolume* holecontour[2];
e21cdd03 5312 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0],
5313 fSSDAlCoolBlockMedium);
9b0c60ab 5314 holecontour[0]->SetLineColor(6);
e21cdd03 5315 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1],
5316 fSSDAlCoolBlockMedium);
9b0c60ab 5317 holecontour[1]->SetLineColor(6);
5318 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5319 + fgkEndCapCoverPlateLength[2],0.,0.);
5320 TGeoTranslation* bigholetrans[3];
5321 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5322 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5323 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5324 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5325 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5326 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5327 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5328 /////////////////////////////////
5329 // Mother Volume Xtru Definition
5330 /////////////////////////////////
5331 const Int_t kmothervertexnumber = 12;
5332 Double_t xmothervertex[kmothervertexnumber];
5333 Double_t ymothervertex[kmothervertexnumber];
5334 xmothervertex[0] = xcontourvertex[0];
5335 xmothervertex[1] = xmothervertex[0];
5336 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5337 xmothervertex[3] = xmothervertex[2];
5338 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5339 xmothervertex[5] = xmothervertex[4];
5340 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5341 xmothervertex[7] = xmothervertex[6];
5342 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5343 + fgkEndCapCoverPlateLength[2];
5344 xmothervertex[9] = xmothervertex[8];
5345 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5346 xmothervertex[11] = xmothervertex[10];
5347
5348 ymothervertex[0] = ycontourvertex[0];
5349 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5350 ymothervertex[2] = ymothervertex[1];
5351 ymothervertex[3] = ycontourvertex[1];
5352 ymothervertex[4] = ymothervertex[3];
5353 ymothervertex[5] = ymothervertex[1];
5354 ymothervertex[6] = ymothervertex[5];
5355 ymothervertex[7] = ymothervertex[0];
5356 ymothervertex[8] = ymothervertex[7];
5357 ymothervertex[9] = ymothervertex[8]
5358 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5359 ymothervertex[10] = ymothervertex[9];
5360 ymothervertex[11] = ymothervertex[8];
5361 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5362 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5363 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5364 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5365 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5366 ////////////////////////////////////////
5367 // Adding Nodes
5368 ////////////////////////////////////////
5369// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5370 TGeoTranslation*** endcapcoverplatesmallholetrans;
5371 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5372 Double_t transx[4] = {0,
5373 fgkEndCapCoverPlateSmallHoleSeparation[0],
5374 fgkEndCapCoverPlateSmallHoleSeparation[0]
5375 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5376 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5377 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5378 Int_t index = 0;
5379 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5380 endcapcoverplatesmallholetrans[i] =
5381 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5382 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5383 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5384 endcapcoverplatesmallholetrans[i][j] =
5385 new TGeoTranslation(transx[i],
5386 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5387 if(index!=10){
5388 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5389 index,endcapcoverplatesmallholetrans[i][j]);
5390 mothercoverplate->AddNode(endcapsmallscrewpiece,
5391 index,endcapcoverplatesmallholetrans[i][j]);
5392 }
5393 if(j<kendcapcoverplatesmallholenumber[1]-1)
5394 mothercoverplate->AddNode(endcapcoverplatebox[0],
5395 index,endcapcoverplatesmallholetrans[i][j]);
5396 }
5397 }
5398 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5399 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5400 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5401 mothercoverplate->AddNode(endcapfillingbox,1);
5402 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5403 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5404 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5405 mothercoverplate->AddNode(holecontour[0],1);
5406 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5407 mothercoverplate->AddNode(holecontour[1],1);
5408 mothercoverplate->AddNode(contour,1);
5409 /////////////////////////////////
5410 return mothercoverplate;
5411 }
5412 ////////////////////////////////////////////////////////////////////////////////
5413 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5414 /////////////////////////////////////////////////////////////
5415 // Getting EndCap Cooling Tube
5416 /////////////////////////////////////////////////////////////
5417 TGeoTorus* endcapcoolingtubetorushape[5];
5418 TGeoVolume* endcapcoolingtubetorus[5];
5419 TGeoTube* endcapcoolingtubeshape[4];
5420 TGeoVolume* endcapcoolingtube[4];
5421 char endcapcoolingtubetorusname[30];
5422 char endcapcoolingtubename[30];
5423 TGeoTorus* endcapcoolingwatertubetorushape[5];
5424 TGeoVolume* endcapcoolingwatertubetorus[5];
5425 TGeoTube* endcapcoolingwatertubeshape[4];
5426 TGeoVolume* endcapcoolingwatertube[4];
5427 char endcapcoolingwatertubetorusname[30];
5428 char endcapcoolingwatertubename[30];
5429 for(Int_t i=0; i<5; i++){
5430 sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5431 sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5432 sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5433 sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5434 if(i==3){
5435 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5436 fgkEndCapCoolingTubeRadiusMin,
5437 fgkEndCapCoolingTubeRadiusMax,
5438 90.0,fgkEndCapCoolingTubeAngle[3]);
5439 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5440 0.,fgkEndCapCoolingTubeRadiusMin,
5441 90.0,fgkEndCapCoolingTubeAngle[3]);
5442 }
5443 else{
5444 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5445 :fgkEndCapCoolingTubeAxialRadius[1],
5446 fgkEndCapCoolingTubeRadiusMin,
5447 fgkEndCapCoolingTubeRadiusMax,
5448 0.,fgkEndCapCoolingTubeAngle[i]);
5449 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5450 :fgkEndCapCoolingTubeAxialRadius[1],
5451 0.,fgkEndCapCoolingTubeRadiusMin,
5452 0.,fgkEndCapCoolingTubeAngle[i]);
5453 }
5454 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5455 endcapcoolingtubetorushape[i],
5456 fSSDCoolingTubePhynox);
5457 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5458 endcapcoolingwatertubetorushape[i],
5459 fSSDCoolingTubeWater);
5460 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5461 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5462 if(i<4){
5463 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5464 fgkEndCapCoolingTubeRadiusMax,
5465 0.5*fgkEndCapCoolingTubeLength[i]);
5466 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5467 0.5*fgkEndCapCoolingTubeLength[i]);
5468 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5469 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5470 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5471 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5472 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5473 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5474 }
5475 }
5476 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5477 /////////////////////////////////////////
5478 // Transformation for Volume Positioning
5479 /////////////////////////////////////////
5480 TGeoCombiTrans* coolingtubecombitrans[6];
5481 TGeoRotation* coolingtuberot[8];
5482 TGeoTranslation* coolingtubetrans[6];
5483 TGeoHMatrix* coolingtubematrix[4];
5484 TGeoCombiTrans* torustubecombitrans[4];
5485 TGeoRotation* torustuberot[7];
5486 TGeoTranslation* torustubetrans[4];
5487 TGeoHMatrix* torustubematrix[5];
5488 TGeoCombiTrans* coolingwatertubecombitrans[6];
5489 TGeoRotation* coolingwatertuberot[8];
5490 TGeoTranslation* coolingwatertubetrans[6];
5491 TGeoHMatrix* coolingwatertubematrix[4];
5492 TGeoCombiTrans* toruswatertubecombitrans[4];
5493 TGeoRotation* toruswatertuberot[7];
5494 TGeoTranslation* toruswatertubetrans[4];
5495 TGeoHMatrix* toruswatertubematrix[5];
5496 for(Int_t i=0; i<8; i++){
5497 if(i<6){
5498 coolingtubetrans[i] = new TGeoTranslation();
5499 coolingwatertubetrans[i] = new TGeoTranslation();
5500 }
5501 if(i<8){
5502 coolingtuberot[i] = new TGeoRotation();
5503 coolingwatertuberot[i] = new TGeoRotation();
5504 }
5505 if(i<4){
5506 torustubetrans[i] = new TGeoTranslation();
5507 toruswatertubetrans[i] = new TGeoTranslation();
5508 }
5509 if(i<7){
5510 torustuberot[i] = new TGeoRotation();
5511 toruswatertuberot[i] = new TGeoRotation();
5512 }
5513 }
5514 /////////////////////////////////////////
5515 // Transformation for Inox Volume Positioning
5516 /////////////////////////////////////////
5517 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5518 -endcapcoolingtubeshape[0]->GetDz(),0.);
5519 coolingtuberot[0]->SetAngles(0.,90.,0.);
5520 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5521 *coolingtuberot[0]);
5522
5523 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5524 coolingtuberot[1]->SetAngles(0.,90.,0.);
5525 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5526 *coolingtuberot[1]);
5527
5528 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5529 *CosD(fgkEndCapCoolingTubeAngle[0]),
5530 fgkEndCapCoolingTubeAxialRadius[0]
5531 *SinD(fgkEndCapCoolingTubeAngle[0]),
5532 0.);
5533 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5534 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5535 *coolingtuberot[2]);
5536
5537 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5538 * (*coolingtubecombitrans[1]));
5539
5540 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5541 endcapcoolingtubeshape[1]->GetDz());
5542 torustuberot[0]->SetAngles(0.,90.,0.);
5543 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5544
5545 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5546
5547 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5548 -endcapcoolingtubeshape[2]->GetDz(),0.);
5549 coolingtuberot[3]->SetAngles(0.,90.,0.);
5550 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5551 *coolingtuberot[3]);
5552 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5553 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5554 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5555
5556 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5557 endcapcoolingtubeshape[2]->GetDz());
5558 torustuberot[1]->SetAngles(0.,90.,0.);
5559 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5560 torustuberot[2]->SetAngles(180.,0.,0.);
5561 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5562 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5563
5564 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5565 -fgkEndCapCoolingTubeAxialRadius[0]);
5566 torustuberot[3]->SetAngles(0.,90.,0.);
5567 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5568 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5569 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5570 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5571
5572 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5573 fgkEndCapCoolingTubeAxialRadius[0],0.);
5574 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5575 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5576 *coolingtuberot[5]);
5577 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5578 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5579 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5580
5581 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5582 endcapcoolingtubeshape[0]->GetDz());
5583 torustuberot[5]->SetAngles(0.,90.,0.);
5584 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5585 torustuberot[6]->SetAngles(-90.,0.,0.);
5586 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5587 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5588
5589 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5590 endcapcoolingtubeshape[3]->GetDz(),0.);
5591 coolingtuberot[6]->SetAngles(0.,90.,0.);
5592 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5593 *coolingtuberot[6]);
5594 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5595 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5596 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5597 /////////////////////////////////////////
5598 // Transformation for Water Volume Positioning
5599 /////////////////////////////////////////
5600 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5601 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5602 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5603 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5604 *coolingwatertuberot[0]);
5605
5606 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5607 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5608 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5609 *coolingwatertuberot[1]);
5610
5611 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5612 *CosD(fgkEndCapCoolingTubeAngle[0]),
5613 fgkEndCapCoolingTubeAxialRadius[0]
5614 *SinD(fgkEndCapCoolingTubeAngle[0]),
5615 0.);
5616 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5617 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5618 *coolingwatertuberot[2]);
5619
5620 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5621 * (*coolingwatertubecombitrans[1]));
5622
5623 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5624 endcapcoolingwatertubeshape[1]->GetDz());
5625 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5626 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5627 *toruswatertuberot[0]);
5628
5629 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5630 * (*toruswatertubecombitrans[0]));
5631
5632 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5633 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5634 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5635 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5636 *coolingwatertuberot[3]);
5637 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5638 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5639 * (*coolingwatertubecombitrans[3]));
5640 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5641
5642 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5643 endcapcoolingwatertubeshape[2]->GetDz());
5644 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5645 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5646 *toruswatertuberot[1]);
5647 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5648 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5649 * (*toruswatertubecombitrans[1]));
5650 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5651
5652 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5653 -fgkEndCapCoolingTubeAxialRadius[0]);
5654 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5655 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5656 *toruswatertuberot[3]);
5657 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5658 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5659 * (*toruswatertubecombitrans[2]));
5660 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5661
5662 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5663 fgkEndCapCoolingTubeAxialRadius[0],0.);
5664 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5665 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5666 *coolingwatertuberot[5]);
5667 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5668 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5669 * (*coolingwatertubecombitrans[4]));
5670 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5671
5672 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5673 endcapcoolingwatertubeshape[0]->GetDz());
5674 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5675 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5676 *toruswatertuberot[5]);
5677 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5678 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5679 * (*toruswatertubecombitrans[3]));
5680 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5681
5682 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5683 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5684 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5685 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5686 *coolingwatertuberot[6]);
5687 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5688 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5689 * (*coolingwatertubecombitrans[5]));
5690 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5691 /////////////////////////////////////////
5692 // Positioning Volumes
5693 /////////////////////////////////////////
5694 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5695 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5696
5697 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5698 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5699
5700 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5701 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5702
5703 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5704 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5705
5706 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5707 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5708
5709 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5710 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5711
5712 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5713 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5714
5715 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5716 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5717
5718 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5719 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5720
5721 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5722 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5723 /////////////////////////////////////////////////////////////
5724 // Deallocating memory
5725 /////////////////////////////////////////////////////////////
5726 for(Int_t i=0; i<8; i++){
5727 if(i<6){
5728 delete coolingtubetrans[i];
5729 delete coolingwatertubetrans[i];
5730 if(i!=0){
5731 delete coolingtubecombitrans[i];
5732 delete coolingwatertubecombitrans[i];
5733 }
5734 }
5735 if(i<8){
5736 delete coolingtuberot[i];
5737 delete coolingwatertuberot[i];
5738 }
5739 if(i<4){
5740 delete torustubetrans[i];
5741 delete toruswatertubetrans[i];
5742 delete torustubecombitrans[i];
5743 delete toruswatertubecombitrans[i];
5744 }
5745 if(i<7){
5746 delete torustuberot[i];
5747 delete toruswatertuberot[i];
5748 }
5749 }
5750 /////////////////////////////////////////////////////////////
5751 return endcapcoolingtubemother;
5752 }
5753 ////////////////////////////////////////////////////////////////////////////////
5754 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5755 /////////////////////////////////////////////////////////////
5756 // Getting EndCap Cover Side
5757 /////////////////////////////////////////////////////////////
5758 const Int_t kendcapcoverholenumber[2] = {7,5};
5759 const Int_t kvertexnumber = 15;
5760 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5761 xvertex[0] = 0.0;
5762 xvertex[1] = xvertex[0];
5763 xvertex[2] = fgkEndCapSideCoverLength[0];
5764 xvertex[3] = fgkEndCapSideCoverLength[1];
5765 xvertex[4] = xvertex[3];
5766 xvertex[5] = fgkEndCapSideCoverLength[2];
5767 xvertex[6] = xvertex[5];
5768 xvertex[7] = xvertex[2];
5769 xvertex[8] = xvertex[7];
5770 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5771 xvertex[10] = xvertex[9];
5772 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5773 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5774 * fgkEndCapSideCoverLength[4];
5775 xvertex[12] = xvertex[11];
5776 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5777 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5778 * fgkEndCapSideCoverLength[4];
5779 xvertex[14] = xvertex[13];
5780 yvertex[0] = 0.0;
5781 yvertex[1] = fgkEndCapSideCoverWidth[0];
5782 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5783 yvertex[3] = yvertex[2];
5784 yvertex[4] = fgkEndCapSideCoverWidth[1];
5785 yvertex[5] = yvertex[4];
5786 yvertex[6] = yvertex[0];
5787 yvertex[7] = yvertex[6];
5788 yvertex[8] = fgkEndCapSideCoverWidth[6];
5789 yvertex[9] = yvertex[8];
5790 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5791 yvertex[11] = yvertex[10];
5792 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5793 yvertex[13] = yvertex[12];
5794 yvertex[14] = yvertex[6];
5795 TGeoXtru* endcapsidecovershape = new TGeoXtru(2);
5796 endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex);
5797 endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5798 endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5799 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5800 endcapsidecovershape,fSSDCoolingTubePhynox);
5801 endcapsidecover->SetLineColor(fColorPhynox);
5802 ////////////////////////////////////////////
5803 // Defininition of Mother Volume
5804 ////////////////////////////////////////////
5805 const Int_t kmothervertexnumber = 7;
5806 Double_t xmothervertex[kmothervertexnumber];
5807 Double_t ymothervertex[kmothervertexnumber];
5808 for(Int_t i=0; i<kmothervertexnumber; i++){
5809 xmothervertex[i] = xvertex[i];
5810 ymothervertex[i] = yvertex[i];
5811 }
5812 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5813 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5814 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5815 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5816 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5817 endcapsidecovermothershape,fSSDAir);
5818 ////////////////////////////////////////////
5819 endcapsidecovermother->AddNode(endcapsidecover,1);
5820 TGeoBBox* endcapsidecoverboxshape[4];
5821 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5822 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5823 0.5*fgkEndCapSideCoverLength[4],
5824 0.5*fgkEndCapSideCoverThickness);
5825 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5826 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5827 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5828 - fgkEndCapSideCoverLength[4]),
5829 0.5*fgkEndCapSideCoverThickness);
5830 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5831 0.5*fgkEndCapSideCoverLength[4],
5832 0.5*fgkEndCapSideCoverThickness);
5833 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5834 0.5*fgkEndCapSideCoverWidth[5],
5835 0.5*fgkEndCapSideCoverThickness);
5836 TGeoVolume* endcapsidecoverbox[4];
5837 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5838 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5839 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5840 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5841 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5842// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5843 TGeoTranslation** endcapsidecoverboxtrans;
5844 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5845 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5846 + fgkEndCapSideCoverLength[0],
5847 endcapsidecoverboxshape[0]->GetDY()
5848 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5849 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5850 + xvertex[11],
5851 endcapsidecoverboxshape[1]->GetDY()
5852 + yvertex[12],0.);
5853 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5854 + xvertex[11],
5855 endcapsidecoverboxshape[2]->GetDY()
5856 + yvertex[12]
5857 + 2.*endcapsidecoverboxshape[1]->GetDY()
5858 + fgkEndCapSideCoverWidth[5],0.);
5859 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5860 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5861 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5862 for(Int_t i=0; i<2; i++)
5863 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5864 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5865 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5866 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5867 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5868 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5869 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5870 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5871 }
5872 for(Int_t i=0; i<2; i++)
5873 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5874 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5875 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5876 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5877 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5878 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5879 +fgkEndCapSideCoverLength[4]),0.0);
5880 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5881 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5882 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5883 +i*(kendcapcoverholenumber[1]-1)+j]);
5884 }
5885 return endcapsidecovermother;
5886 }
5887 ////////////////////////////////////////////////////////////////////////////////
5888 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5889 ////////////////////////////////////////////////////////////////////////////////
5890 // Method returning Interface Card A, Interface Card B, Supply Card
5891 ////////////////////////////////////////////////////////////////////////////////
5892 /////////////////////
5893 // Supply Card
5894 /////////////////////
5895 // Electronic Board Back Al Plane
5896 const Int_t kelectboardbackvertexnumber = 8;
5897 Double_t xelectboardback[kelectboardbackvertexnumber];
5898 Double_t yelectboardback[kelectboardbackvertexnumber];
5899 xelectboardback[0] = 0.0;
5900 xelectboardback[1] = xelectboardback[0];
5901 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5902 xelectboardback[3] = xelectboardback[2];
5903 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5904 xelectboardback[5] = xelectboardback[4];
5905 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5906 xelectboardback[7] = xelectboardback[6];
5907
5908 yelectboardback[0] = 0.0;
5909 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5910 yelectboardback[2] = yelectboardback[1];
5911 yelectboardback[3] = yelectboardback[0];
5912 yelectboardback[4] = yelectboardback[3];
5913 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5914 yelectboardback[6] = yelectboardback[5];
5915 yelectboardback[7] = yelectboardback[4];
5916 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5917 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5918 xelectboardback,yelectboardback);
5919 electboardbackshape->DefineSection(0,0.0);
5920 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5921 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5922 electboardbackshape,fSSDSupportRingAl);
5923 electboardback->SetLineColor(fColorAl);
5924 // Electronic Board Kapton Layer
5925 const Int_t kelectlayervertexnumber = 8;
5926 Double_t xelectlayer[kelectlayervertexnumber];
5927 Double_t yelectlayer[kelectlayervertexnumber];
5928 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5929 xelectlayer[1] = xelectlayer[0];
5930 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5931 xelectlayer[3] = xelectlayer[2];
5932 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5933
5934 yelectlayer[0] = 0.0;
5935 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5936 yelectlayer[2] = yelectlayer[1];
5937 yelectlayer[3] = yelectlayer[0];
5938 yelectlayer[4] = yelectlayer[3];
5939 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5940 yelectlayer[6] = yelectlayer[5];
5941 yelectlayer[7] = yelectlayer[4];
5942 TGeoXtru* electlayershape = new TGeoXtru(2);
5943 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5944 electlayershape->DefineSection(0,0.0);
5945 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5946 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5947 electlayershape,fSSDKaptonFlexMedium);
5948 electlayer->SetLineColor(fColorKapton);
5949 // JMD Connector Female
5950 const Int_t kjmdconnectorvertexnumber = 6;
5951 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5952 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5953 xjmdconnectorvertex[0] = 0.0;
5954 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5955 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5956 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5957 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5958 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5959
5960 yjmdconnectorvertex[0] = 0.0;
5961 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5962 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5963 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5964 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5965 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5966 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5967 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5968 yjmdconnectorvertex);
5969 jmdconnectorshape->DefineSection(0,0.0);
5970 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5971 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5972 jmdconnectorshape,fSSDMountingBlockMedium);
5973 jmdconnector->SetLineColor(fColorG10);
5974 // Top Cable Connector
5975 const Int_t kcableconnectorvertexnumber = 8;
5976 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5977 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5978 xconnectorvertex[0] = 0.0;
5979 xconnectorvertex[1] = xconnectorvertex[0];
5980 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5981 xconnectorvertex[3] = xconnectorvertex[2];
5982 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5983 - fgkEndCapCardCableConnectorLength[2];
5984 xconnectorvertex[5] = xconnectorvertex[4];
5985 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5986 xconnectorvertex[7] = xconnectorvertex[6];
5987
5988 yconnectorvertex[0] = 0.0;
5989 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5990 yconnectorvertex[2] = yconnectorvertex[1];
5991 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5992 yconnectorvertex[4] = yconnectorvertex[3];
5993 yconnectorvertex[5] = yconnectorvertex[1];
5994 yconnectorvertex[6] = yconnectorvertex[5];
5995 yconnectorvertex[7] = yconnectorvertex[0];
5996 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5997 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5998 yconnectorvertex);
5999 cableconnectorshape->DefineSection(0,0.0);
6000 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
6001 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
6002 cableconnectorshape,fSSDMountingBlockMedium);
6003 cableconnector->SetLineColor(fColorG10);
6004 // Strip Connection
6005 TGeoBBox* endcapstripconnectionshape =
6006 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
6007 0.5*fgkEndCapStripConnectionThickness,
6008 0.5*fgkEndCapStripConnectionWidth);
6009 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
6010 endcapstripconnectionshape,
6011 fSSDSupportRingAl);
6012 endcapstripconnection->SetLineColor(fColorAl);
6013 // Interface Card B
6014 const Int_t kcardBvertexnumber = 12;
6015 Double_t xcardBvertexnumber[kcardBvertexnumber];
6016 Double_t ycardBvertexnumber[kcardBvertexnumber];
6017
6018 xcardBvertexnumber[0] = 0.0;
6019 xcardBvertexnumber[1] = xcardBvertexnumber[0];
6020 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
6021 xcardBvertexnumber[3] = xcardBvertexnumber[2];
6022 xcardBvertexnumber[4] = xcardBvertexnumber[1];
6023 xcardBvertexnumber[5] = xcardBvertexnumber[4];
6024 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
6025 xcardBvertexnumber[7] = xcardBvertexnumber[6];
6026 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
6027 xcardBvertexnumber[9] = xcardBvertexnumber[8];
6028 xcardBvertexnumber[10] = xcardBvertexnumber[7];
6029 xcardBvertexnumber[11] = xcardBvertexnumber[10];
6030
6031 ycardBvertexnumber[0] = 0.0;
6032 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
6033 ycardBvertexnumber[2] = ycardBvertexnumber[1];
6034 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
6035 ycardBvertexnumber[4] = ycardBvertexnumber[3];
6036 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
6037 ycardBvertexnumber[6] = ycardBvertexnumber[5];
6038 ycardBvertexnumber[7] = ycardBvertexnumber[4];
6039 ycardBvertexnumber[8] = ycardBvertexnumber[7];
6040 ycardBvertexnumber[9] = ycardBvertexnumber[1];
6041 ycardBvertexnumber[10] = ycardBvertexnumber[9];
6042 ycardBvertexnumber[11] = ycardBvertexnumber[0];
6043
6044 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
6045 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
6046 interfacecardBshape->DefineSection(0,0.);
6047 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
6048 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
6049 fSSDMountingBlockMedium);
6050 interfacecardB->SetLineColor(46);
6051 // Interface Card B Electronic Board
6052 const Int_t kelectboardcardBvertexnumber = 14;
6053 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
6054 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
6055
6056 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
6057 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
6058 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
6059 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
6060 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
6061 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
6062 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6063 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
6064 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6065 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
6066 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6067 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6068 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6069 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6070
6071 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6072 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6073 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
6074 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6075 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
6076 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
6077 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
6078 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6079 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
6080 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6081 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6082 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6083 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6084 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6085
6086 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6087 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6088 xelectboardcardBvertex,yelectboardcardBvertex);
6089 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6090 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6091 + fgkEndCapInterfaceElectBoardCardBThickness);
6092 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6093 fSSDSupportRingAl);
6094 electboardcardB->SetLineColor(fColorAl);
6095 // Generating Stiffener 2
6096 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6097 0.5*fgkEndCapStiffenerThickness,
6098 0.5*fgkEndCapStiffenerLength);
6099 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6100 endcapstiffener->SetLineColor(fColorAl);
6101 // Generating Mother Interface Card B Container
6102 const Int_t kinterfacecardBmothervertexnumber = 10;
6103 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6104 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6105
6106 xinterfacecardBmothervertex[0] = 0.0;
6107 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6108 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6109 + fgkEndCapInterfaceCardBThickness;
6110 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6111 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6112 + fgkEndCapInterfaceElectBoardCardBThickness;
6113 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6114 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6115 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6116 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6117 + fgkEndCapCardJMDConnectorLength[0];
6118 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6119
6120 yinterfacecardBmothervertex[0] = 0.0;
6121 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6122 + fgkEndCapInterfaceCardBWidth[1]
6123 + fgkEndCapInterfaceCardBWidth[2];
6124 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6125 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6126 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6127 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6128 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6129 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6130 + fgkEndCapCardJMDConnectorWidth[0]
6131 + fgkEndCapCardJMDConnectorWidth[1];
6132 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6133 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6134 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6135 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6136 xinterfacecardBmothervertex,
6137 yinterfacecardBmothervertex);
6138 interfacecardBmothershape->DefineSection(0,-1.e-15);
6139 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6140 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6141 interfacecardBmothershape,fSSDAir);
6142 electboardcardB->SetLineColor(fColorAl);
6143 // Positioning Volumes Mother Interface Card B Container
6144 TGeoRotation* interfacecardBrot = new TGeoRotation();
6145 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6146 interfacecardBrot->SetAngles(90.,-90.,-90.);
6147 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6148 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6149 TGeoRotation* electboardcardBrot = new TGeoRotation();
6150 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6151 electboardcardBrot->SetAngles(90.,90.,-90.);
6152 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6153 TGeoCombiTrans* electboardcardBcombitrans =
6154 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6155 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6156 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6157 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6158 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6159 TGeoTranslation* jmdconnectorcardBtrans[3];
6160 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6161 for(Int_t i=0; i<3; i++){
6162 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6163 + fgkEndCapCardJMDConnectorLength[0],
6164 fgkEndCapCardElectBoardLayerWidth[1],
6165 0.5*fgkEndCapCardJMDConnectorThickness
6166 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6167 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6168 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6169 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6170 *jmdconnectorcardBrot);
6171 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6172 }
6173 // Mother Supply Card Container
6174 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6175 // Interface Card Container
6176 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6177 // Placing Volumes in Mother Supply Card Container
6178 // JMD Connector Positioning
6179 TGeoTranslation* jmdconnectortrans[2];
6180 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6181 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6182 fgkEndCapCardElectBoardBackLength[0]
6183 - fgkEndCapCardJMDConnectorThickness
6184 - fgkEndCapCardJMDConnectorToLayer);
6185 TGeoRotation* jmdconnectorot = new TGeoRotation();
6186 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6187 + 2.*fgkEndCapCardJMDConnectorLength[0]
6188 + 2.*fgkEndCapCardElectBoardLayerThickness,
6189 fgkEndCapCardElectBoardLayerWidth[1],
6190 fgkEndCapCardJMDConnectorThickness
6191 + fgkEndCapCardJMDConnectorToLayer);
6192 jmdconnectorot->SetAngles(90.,180.,-90);
6193 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6194 * jmdconnectorot);
6195 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6196 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6197 // Top Cable Connector Placing
6198 TGeoRotation* cableconnectorot[2];
6199 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6200 TGeoTranslation* cableconnectortrans[3];
6201 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6202 cableconnectorot[0]->SetAngles(90.,0.,0.);
6203 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6204 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6205 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6206 *cableconnectorot[0]);
6207 TGeoHMatrix* cableconnectormatrix[2];
6208 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6209 new TGeoHMatrix((*cableconnectorot[1])
6210 *(*cableconnectorcombitrans));
6211 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6212 - fgkEndCapCardCableConnectorThickness,
6213 fgkEndCapCardCableConnectorLength[0]
6214 + fgkEndCapCardCableConnectorToLayer);
6215 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6216 - 2.*fgkEndCapCardCableConnectorThickness
6217 - fgkEndCapCardCableConnectorDistance,
6218 fgkEndCapCardCableConnectorLength[0]
6219 + fgkEndCapCardCableConnectorToLayer);
6220 for(Int_t i=0; i<2; i++){
6221 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6222 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6223 }
6224 TGeoRotation* electboardbackrot = new TGeoRotation();
6225 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6226 electboardbackrot->SetAngles(90.,-90.,-90.);
6227 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6228 + fgkEndCapCardJMDConnectorLength[0]
6229 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6230 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6231 *electboardbackrot);
6232 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6233 // Electronic Board Kapton Layer Positioning
6234 TGeoRotation* electlayerrot = new TGeoRotation();
6235 TGeoTranslation* electlayertrans[2];
6236 TGeoCombiTrans* electlayercombitrans[2];
6237 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6238 electlayerrot->SetAngles(90.,-90.,-90.);
6239 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6240 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6241 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6242 + 2.*fgkEndCapCardElectBoardLayerThickness
6243 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6244 for(Int_t i=0; i<2; i++){
6245 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6246 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6247 }
6248 // Placing Volumes in Mother Interface Card Container
6249 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6250 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6251 for(Int_t i=0; i<2; i++){
6252 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6253 }
6254 /////////////////////////////////////////////////////////////
6255 // Generation of Card Interface Container
6256 /////////////////////////////////////////////////////////////
6257 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6258 - fgkEndCapCardJMDConnectorLength[0]
6259 - fgkEndCapInterfaceCardBThickness
6260 - 9.*fgkEndCapStripConnectionThickness
6261 - 8.*fgkEndCapCardElectBoardBackThickness;
6262 const Int_t kcardinterfacecontainervertexnumber = 14;
6263 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6264 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6265 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6266 - 7.0*fgkEndCapStripConnectionThickness;
6267 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6268 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6269 + fgkEndCapStripConnectionThickness
6270 - fgkEndCapCardElectBoardLayerThickness
6271 - fgkEndCapCardCableConnectorWidth[0];
6272 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6273 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6274 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6275 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6276 + 2.0*fgkEndCapStripConnectionThickness;
6277 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6278 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6279 + fgkEndCapInterfaceCardBThickness;
6280 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6281 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6282 + fgkEndCapInterfaceElectBoardCardBThickness;
6283 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6284 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6285 - fgkEndCapInterfaceElectBoardCardBThickness
6286 + fgkEndCapCardJMDConnectorLength[0]
6287 + stiffenertransx+fgkEndCapStiffenerWidth;
6288 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6289
6290 ycardinterfacecontainervertex[0] = 0.;
6291 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6292 + fgkEndCapCardJMDConnectorWidth[0]
6293 + fgkEndCapCardJMDConnectorWidth[1];
6294 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6295 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6296 - fgkEndCapStripConnectionWidth;
6297 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6298 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6299 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6300 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6301 + fgkEndCapInterfaceCardBWidth[1]
6302 + fgkEndCapInterfaceCardBWidth[2];
6303 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6304 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6305 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6306 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6307 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6308 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6309
6310 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6311 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6312 xcardinterfacecontainervertex,
6313 ycardinterfacecontainervertex);
6314 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6315 - fgkEndCapCardElectBoardBackLength[0]));
6316 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6317 + fgkEndCapCardElectBoardBackLength[0]));
6318 TGeoVolume** cardinterfacecontainer;
6319 cardinterfacecontainer = new TGeoVolume*[4];
6320 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6321 interfacecardmothershape,fSSDAir);
6322 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6323 interfacecardmothershape,fSSDAir);
6324 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6325 interfacecardmothershape,fSSDAir);
6326 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6327 interfacecardmothershape,fSSDAir);
6328 /////////////////////////////////
6329 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6330 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6331 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6332 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6333 /////////////////////////////////
6334 TGeoRotation* endcapstripconnectionrot[2];
6335 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6336 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6337 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6338 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6339 * (*endcapstripconnectionrot[0]));
6340 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6341 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6342 -0.5*fgkEndCapCardElectBoardBackThickness,
6343 fgkEndCapCardElectBoardBackWidth[0]
6344 -endcapstripconnectionshape->GetDZ(),
6345 0.5*fgkEndCapCardElectBoardBackLength[0]);
6346 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6347 TGeoTranslation* cardinterfacetrans[9];
6348 TGeoHMatrix* cardinterfacematrix[9];
6349 for(Int_t i=0; i<7; i++){
6350 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6351 + fgkEndCapCardElectBoardBackThickness),
6352 0.0,0.0);
6353 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6354 * (*endcapstripconnectionmatrix));
6355 }
6356 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6357 + fgkEndCapCardElectBoardBackThickness),
6358 0.0,0.0);
6359 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6360 * (*endcapstripconnectionmatrix));
6361 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6362 + fgkEndCapCardElectBoardBackThickness),
6363 0.0,0.0);
6364 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6365 * (*endcapstripconnectionmatrix));
6366
6367 for(Int_t i=0; i<4; i++){
6368 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6369 cardinterfacematrix[7]);
6370 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6371 cardinterfacematrix[8]);
6372 }
6373 TGeoTranslation* mothersupplycardtrans =
6374 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6375 + 2.*fgkEndCapCardJMDConnectorLength[0]
6376 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6377 TGeoHMatrix* mothersupplycardmatrix[7];
6378 Int_t index[4] = {1,1,1,1};
6379 for(Int_t i=0; i<7; i++){
6380 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6381 * (*mothersupplycardtrans));
6382 for(Int_t j=0; j<4; j++){
6383 switch(j){
6384 case 0: //Layer5 EndCap Left Side
6385 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6386 cardinterfacematrix[i]);
6387 if(i!=0){
6388 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6389 mothersupplycardmatrix[i]);
6390 index[j]++;
6391
6392 }
6393 break;
6394 case 1: //Layer5 EndCap Rigth Side
6395 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6396 cardinterfacematrix[i]);
6397 if(i>0&&i<6){
6398 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6399 mothersupplycardmatrix[i]);
6400 index[j]++;
6401 }
6402 break;
6403 case 2: //Layer6 EndCap Left Side
6404 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6405 cardinterfacematrix[i]);
6406 if(i!=6){
6407 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6408 mothersupplycardmatrix[i]);
6409 index[j]++;
6410 }
6411 break;
6412 case 3: //Layer6 EndCap Right Side
6413 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6414 cardinterfacematrix[i]);
6415 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6416 mothersupplycardmatrix[i]);
6417 index[j]++;
6418 break;
6419 }
6420 }
6421 }
6422 // Positioning Interface
6423 TGeoTranslation* motherinterfacecardtrans =
6424 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6425 +0.5*fgkEndCapCardElectBoardBackThickness
6426 -fgkEndCapCardElectBoardLayerThickness
6427 +fgkEndCapStripConnectionThickness,0.,0.);
6428 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6429 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6430 // Positioning Interface Card B
6431 TGeoTranslation* interfacecardBmothertrans =
6432 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6433 + 2.*fgkEndCapStripConnectionThickness
6434 + fgkEndCapCardElectBoardBackThickness,0.,
6435 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6436 - fgkEndCapCardElectBoardBackLength[0]));
6437 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6438 interfacecardBmothertrans);
6439 // Positioning Stiffener
6440 TGeoTranslation* endcapstiffenertrans =
6441 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6442 + 2.0*fgkEndCapStripConnectionThickness
6443 + fgkEndCapInterfaceCardBThickness
6444 + fgkEndCapCardJMDConnectorLength[0]
6445 + stiffenertransx
6446 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6447 endcapstiffenershape->GetDZ()
6448 - 0.5*(fgkEndCapStiffenerLength
6449 - fgkEndCapCardElectBoardBackLength[0]));
6450 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6451 /////////////////////////////////////////////////////////////
6452 // Deallocating memory
6453 /////////////////////////////////////////////////////////////
6454 delete interfacecardBrot;
6455 delete interfacecardBtrans;
6456 delete electboardcardBtrans;
6457 delete electboardcardBrot;
6458 delete jmdconnectorcardBrot;
6459 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6460 delete jmdconnectorot;
6461 delete jmdconnectortrans[1];
6462 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6463 delete cableconnectorcombitrans;
6464 delete electboardbacktrans;
6465 delete electboardbackrot;
6466 delete electlayerrot;
6467 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6468 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6469 delete mothersupplycardtrans;
6470 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6471 /////////////////////////////////////////////////////////////
6472 return cardinterfacecontainer;
6473 }
6474 ////////////////////////////////////////////////////////////////////////////////
6475 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6476 /////////////////////////////////////////////////////////////
6477 // Method returning EndCap Mother Volume
6478 /////////////////////////////////////////////////////////////
6479 const Int_t kendcapcoverplatesmallholenumber = 9;
6480 Double_t endcapmotherorigin[3];
6481 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6482 + 0.5 *(fgkEndCapCoverPlateLength[3]
6483 + 2.0 * fgkEndCapCoverPlateLength[2]);
6484 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6485 - fgkEndCapCoverPlateWidth[2]
6486 - (kendcapcoverplatesmallholenumber-1)
6487 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6488 + 0.5*(fgkEndCapSideCoverLength[2]
6489 + fgkEndCapCoverPlateWidth[1]
6490 - fgkEndCapCoverPlateWidth[0])
6491 - (fgkEndCapCoverPlateWidth[1]
6492 - fgkEndCapCoverPlateWidth[0]);
6493 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6494 + 2.*fgkEndCapCoolingTubeRadiusMax
6495 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6496 + fgkEndCapSideCoverWidth[1]
6497 + fgkEndCapSideCoverThickness
6498 + fgkEndCapKaptonFoilThickness);
6499 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6500 + 2.0* fgkEndCapCoverPlateLength[2]
6501 + 2.0* fgkEndCapSideCoverThickness),
6502 0.5* (fgkEndCapSideCoverLength[2]
6503 + fgkEndCapCoverPlateWidth[1]
6504 - fgkEndCapCoverPlateWidth[0]),
6505 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6506 + fgkEndCapSideCoverWidth[1]
6507 + fgkEndCapSideCoverThickness
6508 + fgkEndCapKaptonFoilThickness),
6509 endcapmotherorigin);
6510 TGeoVolume** endcapassembly;
6511 endcapassembly = new TGeoVolume*[4];
6512 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6513 endcapmothershape,fSSDAir);
6514 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6515 endcapmothershape,fSSDAir);
6516 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6517 endcapmothershape,fSSDAir);
6518 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6519 endcapmothershape,fSSDAir);
6520 /////////////////////////////////
6521 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6522 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6523 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6524 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6525 /////////////////////////////////
6526 /////////////////////////////////////////////////////
6527 // Placing Endcap Cover Plate
6528 /////////////////////////////////////////////////////
6529 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6530 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6531 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6532 TGeoCombiTrans* endcapcoverplatecombitrans =
6533 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6534 endcapcoverplaterot);
6535 TGeoTranslation* endcapcoverplatetrans =
6536 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6537 TGeoHMatrix* endcapcoverplatematrix =
6538 new TGeoHMatrix((*endcapcoverplatetrans)
6539 * (*endcapcoverplatecombitrans));
6540 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6541 /////////////////////////////////////////////////////
6542 // Placing Endcap Side Cover
6543 /////////////////////////////////////////////////////
6544 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6545 TGeoRotation* endcapsidecoverot[2];
6546 TGeoCombiTrans* endcapsidecovercombitrans[3];
6547 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6548 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6549 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6550 - 0.5*(fgkEndCapCoverPlateWidth[0]
6551 - fgkEndCapCoverPlateWidth[2]
6552 - (kendcapcoverplatesmallholenumber-1)
6553 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6554 + 0.*fgkEndCapCoverPlateWidth[0]
6555 + fgkEndCapSideCoverLength[2],
6556 0.5*(fgkEndCapSideCoverThickness
6557 + fgkEndCapCoverPlateThickness)
6558 - 0.5*fgkEndCapCoverPlateThickness,
6559 endcapsidecoverot[0]);
6560 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6561 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6562 0.5*fgkEndCapCoverPlateThickness
6563 -fgkEndCapSideCoverWidth[1],
6564 endcapsidecoverot[1]);
6565 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6566 +fgkEndCapCoverPlateLength[3]
6567 +2.*fgkEndCapCoverPlateLength[2]
6568 +fgkEndCapSideCoverThickness,0.0,
6569 0.5*fgkEndCapCoverPlateThickness
6570 -fgkEndCapSideCoverWidth[1],
6571 endcapsidecoverot[1]);
6572 TGeoHMatrix* endcapsidecovermatrix[2];
6573 for(Int_t i=0; i<2; i++){
6574 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6575 * (*endcapsidecovercombitrans[0]));
6576 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6577 endcapsidecovermatrix[i]);
6578 }
6579 /////////////////////////////////////////////////////
6580 // Placing Endcap Cooling Tube
6581 /////////////////////////////////////////////////////
6582 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6583 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6584 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6585 TGeoCombiTrans* endcapccolingtubecombitrans
6586 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6587 + fgkEndCapCoolingTubeAxialRadius[1])
6588 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6589 - fgkEndCapCoolingTubeToCoverSide,
6590 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6591 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6592 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6593 endcapccolingtubecombitrans);
6594 /////////////////////////////////////////////////////
6595 // Placing Screws
6596 /////////////////////////////////////////////////////
6597 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6598 fgkEndCapCoverPlateScrewRadiusMin};
6599 Int_t screwcoverplatedgesnumber[2] = {20,20};
6600 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6601 fgkEndCapCoverPlateThickness
6602 + fgkEndCapCoolingTubeRadiusMax};
6603 TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6604 screwcoverplatedgesnumber,
6605 screwcoverplatesection);
6606 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6607 screwcoverplateshape,
6608 fSSDCoolingTubePhynox);
6609 screwcoverplate->SetLineColor(12);
6610 Double_t transx[4] = {0,
6611 fgkEndCapCoverPlateSmallHoleSeparation[0],
6612 fgkEndCapCoverPlateSmallHoleSeparation[0]
6613 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6614 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6615 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6616 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6617// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6618 TGeoTranslation*** endcapcoverplatescrewtrans;
6619 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6620 Int_t index = 0;
6621 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6622 endcapcoverplatescrewtrans[i] =
6623 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6624 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6625 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6626 if(index==1||index==9||index==28||index==36){
6627 endcapcoverplatescrewtrans[i][j] =
6628 new TGeoTranslation(transx[i],
6629 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6630 fgkEndCapSideCoverThickness);
6631 }
6632 else{
6633 endcapcoverplatescrewtrans[i][j] =
6634 new TGeoTranslation(transx[i],
6635 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6636 0.);
6637 }
6638 if(index!=19)
6639 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6640 endcapcoverplatescrewtrans[i][j]);
6641 }
6642 }
6643 /////////////////////////////////////////////////////
6644 // Placing Cover Plate Clips
6645 /////////////////////////////////////////////////////
6646 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6647 0.5*fgkEndCapCoverPlateClipWidth,
6648 0.5*fgkEndCapSideCoverThickness);
6649 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6650 endcapcoverplateclipshape,
6651 fSSDCoolingTubePhynox);
6652 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6653 0.5*fgkEndCapCoverPlateDownClipWidth,
6654 0.5*fgkEndCapSideCoverThickness);
6655 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6656 endcapcoverplatedownclipshape,
6657 fSSDCoolingTubePhynox);
6658 TGeoTranslation* endcapcoverplatecliptrans[4];
6659 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6660 - fgkEndCapCoverPlateLength[0]
6661 - fgkEndCapSideCoverThickness,
6662 0.0,
6663 0.5*(fgkEndCapSideCoverThickness
6664 + fgkEndCapCoverPlateThickness));
6665 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6666 - fgkEndCapCoverPlateLength[0]
6667 - fgkEndCapSideCoverThickness,
6668 (kendcapcoverplatescrewnumber[1]-1)
6669 * fgkEndCapSideCoverWidth[5],
6670 0.5*(fgkEndCapSideCoverThickness
6671 + fgkEndCapCoverPlateThickness));
6672 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6673 - fgkEndCapCoverPlateLength[0]
6674 + fgkEndCapCoverPlateLength[1]
6675 + 2.*fgkEndCapCoverPlateLength[0]
6676 - fgkEndCapCoverPlateClipLength
6677 + fgkEndCapSideCoverThickness,
6678 0.0,
6679 0.5*(fgkEndCapSideCoverThickness
6680 + fgkEndCapCoverPlateThickness));
6681 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6682 - fgkEndCapCoverPlateLength[0]
6683 + fgkEndCapCoverPlateLength[1]
6684 + 2.*fgkEndCapCoverPlateLength[0]
6685 - fgkEndCapCoverPlateClipLength
6686 + fgkEndCapSideCoverThickness,
6687 (kendcapcoverplatescrewnumber[1]-1)
6688 * fgkEndCapSideCoverWidth[5],
6689 0.5*(fgkEndCapSideCoverThickness
6690 + fgkEndCapCoverPlateThickness));
6691 endcapcoverplateclip->SetLineColor(fColorPhynox);
6692 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6693 for(Int_t i=0; i<4; i++)
6694 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6695 endcapcoverplatecliptrans[i]);
6696 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6697 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6698 - fgkEndCapCoverPlateLength[0]
6699 - fgkEndCapSideCoverThickness,
6700 0.5*(fgkEndCapCoverPlateDownClipWidth
6701 - fgkEndCapCoverPlateClipWidth),
6702 0.5*(fgkEndCapSideCoverThickness
6703 + fgkEndCapCoverPlateThickness)
6704 - fgkEndCapSideCoverWidth[1]
6705 - fgkEndCapSideCoverThickness);
6706 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6707 - fgkEndCapCoverPlateLength[0]
6708 - fgkEndCapSideCoverThickness,
6709 0.5*(fgkEndCapCoverPlateDownClipWidth
6710 - fgkEndCapCoverPlateClipWidth)
6711 + fgkEndCapSideCoverLength[2]
6712 - fgkEndCapCoverPlateDownClipWidth,
6713 0.5*(fgkEndCapSideCoverThickness
6714 + fgkEndCapCoverPlateThickness)
6715 - fgkEndCapSideCoverWidth[1]
6716 - fgkEndCapSideCoverThickness);
6717 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6718 - fgkEndCapCoverPlateLength[0]
6719 + fgkEndCapSideCoverThickness
6720 + fgkEndCapCoverPlateLength[1]
6721 + 2.0*fgkEndCapCoverPlateLength[0]
6722 - fgkEndCapCoverPlateDownClipLength,
6723 0.5*(fgkEndCapCoverPlateDownClipWidth
6724 - fgkEndCapCoverPlateClipWidth),
6725 0.5*(fgkEndCapSideCoverThickness
6726 + fgkEndCapCoverPlateThickness)
6727 - fgkEndCapSideCoverWidth[1]
6728 - fgkEndCapSideCoverThickness);
6729 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6730 - fgkEndCapCoverPlateLength[0]
6731 + fgkEndCapSideCoverThickness
6732 + fgkEndCapCoverPlateLength[1]
6733 + 2.0*fgkEndCapCoverPlateLength[0]
6734 - fgkEndCapCoverPlateDownClipLength,
6735 0.5*(fgkEndCapCoverPlateDownClipWidth
6736 - fgkEndCapCoverPlateClipWidth)
6737 + fgkEndCapSideCoverLength[2]
6738 - fgkEndCapCoverPlateDownClipWidth,
6739 0.5*(fgkEndCapSideCoverThickness
6740 + fgkEndCapCoverPlateThickness)
6741 - fgkEndCapSideCoverWidth[1]
6742 - fgkEndCapSideCoverThickness);
6743 for(Int_t i=0; i<4; i++)
6744 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6745 endcapcoverplatedowncliptrans[i]);
6746 /////////////////////////////////////////////////////
6747 // Placing Kapton Foil
6748 /////////////////////////////////////////////////////
6749 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6750 0.5*fgkEndCapKaptonFoilWidth,
6751 0.5*fgkEndCapKaptonFoilThickness);
6752 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6753 endcapkaptonfoilshape,
6754 fSSDKaptonFlexMedium);
6755 endcapkaptonfoil->SetLineColor(8);
6756 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6757 0.5*fgkEndCapKaptonFoilWidth
6758 - 0.5*fgkEndCapCoverPlateClipWidth,
6759 0.5*fgkEndCapCoverPlateThickness
6760 - 0.5*fgkEndCapKaptonFoilThickness
6761 - fgkEndCapSideCoverWidth[1]
6762 - fgkEndCapSideCoverThickness);
6763 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6764 /////////////////////////////////////////////////////////////
6765 // Placing Electronic Tubes
6766 /////////////////////////////////////////////////////////////
6767 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6768 - fgkEndCapInterfaceCardBThickness
6769 - 9.*fgkEndCapStripConnectionThickness
6770 - 8.*fgkEndCapCardElectBoardBackThickness,
6771 fgkEndCapKaptonFoilWidth
6772 - fgkEndCapInterfaceCardBThickness
6773 - 9.*fgkEndCapStripConnectionThickness
6774 - 8.*fgkEndCapCardElectBoardBackThickness
6775 - fgkEndCapInterfaceElectBoardCardBThickness};
6776 TGeoVolume* endcapeffectivecables[2];
6777 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6778 fgkEndCapEffectiveCableRadiusMax,
6779 endcapeffectivecableswidth[0],
6780 10,"EndCapEffectiveCables1");
6781 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6782 fgkEndCapEffectiveCableRadiusMax,
6783 endcapeffectivecableswidth[1],
6784 25,"EndCapEffectiveCables2");
6785 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6786 TGeoTranslation* endcapeffectivecablestrans[2];
6787 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6788 - 0.5*endcapeffectivecableswidth[0]
6789 - 0.5*(fgkEndCapCoverPlateWidth[0]
6790 - fgkEndCapCoverPlateWidth[2]
6791 - (kendcapcoverplatesmallholenumber-1)
6792 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6793 + fgkEndCapSideCoverLength[2],
6794 - 0.5*fgkEndCapCoverPlateThickness
6795 - (fgkEndCapCardElectBoardBackWidth[0]
6796 - fgkEndCapInterfaceCardBWidth[0]
6797 - fgkEndCapInterfaceCardBWidth[1]));
6798 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6799 - 0.5*endcapeffectivecableswidth[1]
6800 - 0.5*(fgkEndCapCoverPlateWidth[0]
6801 - fgkEndCapCoverPlateWidth[2]
6802 - (kendcapcoverplatesmallholenumber-1)
6803 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6804 + fgkEndCapSideCoverLength[2],
6805 - 0.5*fgkEndCapCoverPlateThickness
6806 - (fgkEndCapCardElectBoardBackWidth[0]
6807 - fgkEndCapInterfaceCardBWidth[0])
6808 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6809 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6810 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6811 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6812 *endcapeffectivecablesrot);
6813 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6814 *endcapeffectivecablesrot);
47f8de53 6815// for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6816// endcapeffectivecablescombitrans[0]);
9b0c60ab 6817 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6818 endcapeffectivecablescombitrans[1]);
6819 /////////////////////////////////////////////////////////////
6820 // Placing End Cap Cards
6821 /////////////////////////////////////////////////////////////
6822 TGeoVolume** endcapcards = GetEndCapCards();
6823 TGeoRotation* endcapcardsrot[2];
6824 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6825 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6826 TGeoTranslation* endcapcardstrans[2];
6827 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6828 - fgkEndCapCardElectBoardBackLength[0]));
6829 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6830 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6831 TGeoHMatrix* endcapcardsmatrix[2];
6832 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6833 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6834 - fgkEndCapCardJMDConnectorLength[0]
6835 - fgkEndCapInterfaceCardBThickness
6836 - 9.*fgkEndCapStripConnectionThickness
6837 - 8.*fgkEndCapCardElectBoardBackThickness;
6838 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6839 - fgkEndCapCoverPlateLength[0]
6840 + 0.5 * (fgkEndCapCoverPlateLength[3]
6841 + 2.0 * fgkEndCapCoverPlateLength[2]),
6842 - stiffenertransx-fgkEndCapStiffenerWidth
6843 - fgkEndCapCardJMDConnectorLength[0]
6844 - fgkEndCapInterfaceCardBThickness
6845 - 2.0 * fgkEndCapStripConnectionThickness
6846 - 1.5 * fgkEndCapInterfaceCardBThickness
6847 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6848 - fgkEndCapCoverPlateWidth[2]
6849 - (kendcapcoverplatesmallholenumber-1)
6850 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6851 + fgkEndCapKaptonFoilWidth,
6852 0.5*fgkEndCapCoverPlateThickness
6853 - fgkEndCapSideCoverWidth[1]);
6854 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6855 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6856 /////////////////////////////////////////////////////////////
6857 // Deallocating memory
6858 /////////////////////////////////////////////////////////////
6859 delete endcapcoverplaterot;
6860 delete endcapcoverplatecombitrans;
6861 delete endcapcoverplatetrans;
6862 for(Int_t i=0; i<3; i++){
6863 delete endcapsidecovercombitrans[i];
6864 if(i<2) delete endcapsidecoverot[i];
6865 }
6866 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6867 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6868 delete endcapcardsmatrix[0];
6869 return endcapassembly;
6870 }
6871 ////////////////////////////////////////////////////////////////////////////////
6872 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6873 Double_t radiusmax,
6874 Double_t width,
6875 Int_t ncables,
6876 char* volname){
6877 /////////////////////////////////////////////////////////////
6878 // Generating EndCap High Voltage Tubes
6879 /////////////////////////////////////////////////////////////
6880 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6881 Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.)
6882 + TMath::Power(radiusmax,2.)
6883 - TMath::Power(radiusmin,2.));
6884 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6885 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6886 effectiveouteradius,0.5*width);
6887 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6888 effectiveinnertubeshape,
6889 fSSDStiffenerConnectorMedium);
6890 effectiveinnertube->SetLineColor(41);
6891 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6892 effectiveoutertubeshape,
6893 fSSDKaptonChipCableMedium);
6894 effectiveoutertube->SetLineColor(39);
6895 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6896 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6897 effectivemothertube->AddNode(effectiveinnertube,1);
6898 effectivemothertube->AddNode(effectiveoutertube,1);
6899 return effectivemothertube;
6900 }
6901 ////////////////////////////////////////////////////////////////////////////////
6902 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6903 /////////////////////////////////////////////////////////////
6904 // Generating EndCap Support Layer 5 and Layer 6
6905 /////////////////////////////////////////////////////////////
6906 const Int_t knedges = 5;
6907 ///////////////////////////////////////////////
6908 // Setting the vertices for TGeoXtru Up Volume
6909 ///////////////////////////////////////////////
6910 const Int_t klayernumber = 2;
6911 Double_t xupvertex[klayernumber][knedges+3];
6912 Double_t yupvertex[klayernumber][knedges+3];
6913 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6914 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6915 Double_t middlepsi[klayernumber] = {0.0,0.0};
6916 for(Int_t i=0; i<klayernumber; i++){
6917 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6918 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6919 xupvertex[i][2] = -xupvertex[i][1];
6920 xupvertex[i][3] = -xupvertex[i][0];
6921
6922 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6923 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6924 yupvertex[i][2] = yupvertex[i][1];
6925 yupvertex[i][3] = yupvertex[i][0];
6926
6927 middledgeangle[i] = upedgeangle[i]/knedges;
6928 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6929 for(Int_t j=1; j<knedges; j++){
6930 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6931 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6932 }
6933 }
6934 ////////////////////////////////////
6935 // Generating Up TGeoXtru
6936 ////////////////////////////////////
6937 TGeoXtru* upendcapsupportshape[klayernumber];
6938 TGeoVolume* upendcapsupport[klayernumber];
6939 char upendcapsupportname[30];
6940 for(Int_t i=0; i<klayernumber; i++){
6941 upendcapsupportshape[i] = new TGeoXtru(2);
6942 sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6943 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6944 upendcapsupportshape[i]->DefineSection(0,0.);
6945 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6946 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 6947 fSSDSupportRingAl);
9b0c60ab 6948 upendcapsupport[i]->SetLineColor(5);
6949 }
6950 ///////////////////////////////////////////////
6951 // Setting the vertices for TGeoXtru Down Volume
6952 ///////////////////////////////////////////////
6953 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6954 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6955 for(Int_t i=0; i<klayernumber; i++){
6956 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6957 xdownvertex[i][1] = xupvertex[i][0];
6958 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6959 ydownvertex[i][1] = yupvertex[i][0];
6960 for(Int_t j=0; j<knedges; j++){
6961 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6962 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6963 }
6964 for(Int_t j=0; j<knedges; j++){
6965 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6966 * CosD(middlepsi[i]+j*middledgeangle[i]);
6967 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6968 * SinD(middlepsi[i]+j*middledgeangle[i]);
6969 }
6970 }
6971 ////////////////////////////////////
6972 // Generating Down TGeoXtru
6973 ////////////////////////////////////
6974 TGeoXtru* downendcapsupportshape[klayernumber];
6975 TGeoVolume* downendcapsupport[klayernumber];
6976 char downendcapsupportname[30];
6977 for(Int_t i=0; i<klayernumber; i++){
6978 downendcapsupportshape[i] = new TGeoXtru(2);
6979 sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
6980 downendcapsupportshape[i] = new TGeoXtru(2);
6981 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6982 if(i==0){
6983 downendcapsupportshape[i]->DefineSection(0,0.);
6984 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6985 }
6986 else{
6987 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6988 - fgkEndCapSupportLowWidth[i]);
6989 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6990 }
6991 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 6992 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 6993 downendcapsupport[i]->SetLineColor(5);
6994 }
6995 ///////////////////////////////////////////////
6996 // Setting TGeoPgon Volume
6997 ///////////////////////////////////////////////
6998 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6999 fgkSSDLay6LadderNumber};
7000 TGeoPgon* endcapsupportmothershape[klayernumber];
7001 TGeoVolume** endcapsupportmother;
7002 endcapsupportmother = new TGeoVolume*[klayernumber];
7003 char endcapsupportmothername[30];
7004 for(Int_t i=0; i<klayernumber; i++){
7005 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7006 sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
7007 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
7008 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
7009 ydownvertex[i][0],yupvertex[i][1]);
7010 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 7011 fSSDAir);
9b0c60ab 7012 }
7013 ////////////////////////////////////
7014 TGeoRotation** endcapsupportrot[klayernumber];
7015 for(Int_t i=0; i<2; i++){
7016 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
7017 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7018 endcapsupportrot[i][j] = new TGeoRotation();
7019 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
7020 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
7021 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
7022 }
7023 }
7024 return endcapsupportmother;
7025 }
7026 ////////////////////////////////////////////////////////////////////////////////
7027 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
7028 /////////////////////////////////////////////////////////////
7029 // Setting End Cap Support Layer 5 and 6.
7030 /////////////////////////////////////////////////////////////
7031 const Int_t kendcapcoverplatesmallholenumber = 9;
7032 const Int_t klayernumber = 2;
7033 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
7034 fgkSSDLay6LadderNumber};
7035 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
7036 360.0/kssdlayladdernumber[1]};
7037 TGeoVolume** endcapsupport = EndCapSupport();
7038 TGeoVolume** endcapassembly = GetEndCapAssembly();
7039 TGeoPgon* endcapsupportshape[klayernumber];
7040 Double_t* radiusmin[klayernumber];
7041 Double_t* radiusmax[klayernumber];
7042 for(Int_t i=0; i<klayernumber; i++){
7043 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
7044 radiusmin[i] = endcapsupportshape[i]->GetRmin();
7045 radiusmax[i] = endcapsupportshape[i]->GetRmax();
7046 }
7047 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
7048 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
7049 endcapassemblyshape->GetDY(),
7050 endcapassemblyshape->GetDZ()};
7051 ///////////////////////////////////////////////
7052 // Setting TGeoPgon Volume for Mother Container
7053 ///////////////////////////////////////////////
7054 TGeoPgon* endcapsupportsystemshape[klayernumber];
7055 char endcapsupportsystemothername[30];
7056 for(Int_t i=0; i<klayernumber; i++){
7057 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7058 sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
7059 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
7060 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
7061 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7062 +2.*endcapassemblycenter[2])
7063 /CosD(0.5*upedgeangle[i]));
7064 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7065 -(fgkEndCapCoverPlateWidth[1]
7066 - fgkEndCapCoverPlateWidth[0]),
7067 *radiusmin[i],
7068 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7069 +2.*endcapassemblycenter[2])
7070 /CosD(0.5*upedgeangle[i]));
7071 }
e5bf64ae 7072 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 7073 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7074 endcapsupportsystemshape[0],fSSDAir);
7075 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7076 endcapsupportsystemshape[0],fSSDAir);
7077 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7078 endcapsupportsystemshape[1],fSSDAir);
7079 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7080 endcapsupportsystemshape[1],fSSDAir);
7081 ///////////////////////////////////////////////
7082 TGeoTranslation* endcapassemblytrans[klayernumber];
7083 for(Int_t i=0; i<klayernumber; i++)
7084 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7085 - fgkEndCapSideCoverThickness
7086 + endcapassemblycenter[0],
7087 - 0.5*fgkEndCapCoverPlateThickness
7088 - 2.0*fgkEndCapCoolingTubeRadiusMax
7089 + 2.0*endcapassemblycenter[2]
7090 + 0.5*fgkEndCapSupportLength[i]
7091 / TanD(0.5*upedgeangle[i]),
7092 0.5*(fgkEndCapCoverPlateWidth[0]
7093 - fgkEndCapCoverPlateWidth[2]
7094 - (kendcapcoverplatesmallholenumber-1)
7095 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
7096 TGeoRotation** endcapassemblyrot[klayernumber];
7097 TGeoHMatrix** endcapassemblymatrix[klayernumber];
7098 for(Int_t i=0; i<klayernumber; i++){
7099 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7100 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7101 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7102 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7103 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7104 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7105 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7106 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7107 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7108 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7109 }
7110 }
7111 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7112 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7113 for(Int_t i=0; i<2*klayernumber; i++){
7114 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7115 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7116 endcapassemblymatrix[1][j+2]);
7117 }
7118 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7119 }
7120 /////////////////////////////////////////////////////////////
7121 // Deallocating memory
7122 /////////////////////////////////////////////////////////////
7123 for(Int_t i=0; i<klayernumber; i++){
7124 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7125 delete endcapassemblyrot[i][j];
7126 }
7127 delete endcapassemblyrot[i];
7128 delete endcapassemblymatrix[i][0];
7129 delete endcapassemblymatrix[i][1];
7130 }
7131 /////////////////////////////////////////////////////////////
7132 }
7133 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7134 /////////////////////////////////////////////////////////////
7135 // Setting End Cap Support + End Cap Assembly of Layer 5.
7136 /////////////////////////////////////////////////////////////
7137 if (! moth) {
7138 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, mother is null!\n");
7139 return;
7140 };
e5bf64ae 7141 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7142 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7143 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7144 fgkEndCapSupportCenterLay5ITSPosition
7145 + fgkEndCapSupportCenterLay5Position
7146 - fgkEndCapSideCoverLength[2]);
7147 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7148 fgkEndCapSideCoverLength[2]
7149 - fgkEndCapSupportCenterLay5Position
7150 - fgkEndCapSupportCenterLay5ITSPosition);
7151 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7152 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7153 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7154 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7155 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7156 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7157 /////////////////////////////////////////////////////////////
7158 // Deallocating memory
7159 /////////////////////////////////////////////////////////////
7160 delete endcapsupportsystemrot;
7161 delete endcapsupportsystemITSCentertrans[1];
7162 }
7163 /////////////////////////////////////////////////////////////
7164 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7165 /////////////////////////////////////////////////////////////
7166 // Setting End Cap Support + End Cap Assembly of Layer 6.
7167 /////////////////////////////////////////////////////////////
7168 if (! moth) {
7169 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
7170 return;
7171 };
e5bf64ae 7172 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7173 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7174 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7175 fgkEndCapSupportCenterLay6ITSPosition
7176 + fgkEndCapSupportCenterLay6Position
7177 - fgkEndCapSideCoverLength[2]);
7178 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7179 fgkEndCapSideCoverLength[2]
7180 - fgkEndCapSupportCenterLay6Position
7181 - fgkEndCapSupportCenterLay6ITSPosition);
7182 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7183 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7184 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7185 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7186 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7187 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7188 /////////////////////////////////////////////////////////////
7189 // Deallocating memory
7190 /////////////////////////////////////////////////////////////
7191 delete endcapsupportsystemrot;
7192 delete endcapsupportsystemITSCentertrans[1];
7193 }
7194 ////////////////////////////////////////////////////////////////////////////////
7195 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7196 /////////////////////////////////////////////////////////////
7197 // Setting Ladder Support of Layer 5.
7198 /////////////////////////////////////////////////////////////
7199 if (! moth) {
7200 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
7201 return;
7202 };
7203 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7204 fMotherVol = moth;
7205 TGeoTranslation* centerITSRingSupportLay5trans[2];
7206 for(Int_t i=0; i<2; i++){
7207 centerITSRingSupportLay5trans[i] =
7208 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7209 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7210 }
7211 }
7212 ////////////////////////////////////////////////////////////////////////////////
7213 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7214 /////////////////////////////////////////////////////////////
7215 // Setting Ladder Support of Layer 6.
7216 /////////////////////////////////////////////////////////////
7217 if (! moth) {
7218 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
7219 return;
7220 };
7221 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7222 fMotherVol = moth;
7223 TGeoTranslation* centerITSRingSupportLay6trans[2];
7224 for(Int_t i=0; i<2; i++){
7225 centerITSRingSupportLay6trans[i] =
7226 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7227 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7228 }
7229 }
7230 ////////////////////////////////////////////////////////////////////////////////
47f8de53 7231 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7232 /////////////////////////////////////////////////////////////
7233 // Setting Ladder Support of Layer 6.
7234 /////////////////////////////////////////////////////////////
7235 if (! moth) {
7236 printf("Error::AliITSv11GeometrySSD: Can't insert SSD Cone, mother is null!\n");
7237 return;
7238 };
7239 if(!fSSDCone) SetSSDCone();
7240 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7241 + fgkSSDCentralAL3SupportLength);
7242 moth->AddNode(fSSDCone,1,ssdconetrans);
7243}
7244 ////////////////////////////////////////////////////////////////////////////////
7245 void AliITSv11GeometrySSD::SetSSDCone(){
7246 /////////////////////////////////////////////////////////////
7247 // Method generating SSDCone
7248 /////////////////////////////////////////////////////////////
7249 if(!fCreateMaterials) CreateMaterials();
7250 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7251 Double_t ssdpconesectionradiusmax[16];
7252 Double_t ssdpconesectionradiusmin[16];
7253 Double_t ssdpconezsection[16];
7254 TGeoPcon* ssdpconelittleholeshape[8];
7255 TGeoVolume* ssdpconelittlehole[8];
7256 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7257 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7258 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7259 / SinD(fgkSSDPConeAngle)
7260 + ssdpconesectionradiusmin[0];
7261 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7262 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7263 / SinD(fgkSSDPConeAngle);
7264 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7265 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7266 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7267 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7268 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7269 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7270 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7271 ssdpconelittlehole[0]->SetLineColor(4);
7272 /////////////////////////////////////////////////////////////
7273 ssdpconezsection[2] = ssdpconezsection[1];
7274 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7275 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7276 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7277 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7278 / SinD(fgkSSDPConeAngle);
7279 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7280 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7281 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7282 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7283 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7284 * TMath::RadToDeg();
7285 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7286 60.-ssdpconelittleholeangle,2);
7287 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7288 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7289 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7290 ssdpconelittlehole[1]->SetLineColor(4);
7291 TGeoRotation* ssdconelittleholerot[6];
7292 for(Int_t i=0; i<6; i++){
7293 ssdconelittleholerot[i] = new TGeoRotation();
7294 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7295 }
7296 /////////////////////////////////////////////////////////////
7297 ssdpconezsection[4] = ssdpconezsection[3];
7298 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7299 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7300 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7301 * CosD(fgkSSDPConeAngle)
7302 / SinD(fgkSSDPConeAngle);
7303 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7304 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7305 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7306 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7307 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7308 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7309 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7310 ssdpconelittlehole[2]->SetLineColor(4);
7311 ///////////////////////////////////////////////////
7312 ssdpconezsection[6] = ssdpconezsection[5];
7313 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7314 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7315 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7316 -ssdpconezsection[0]
7317 * CosD(fgkSSDPConeAngle)
7318 / SinD(fgkSSDPConeAngle);
7319 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7320 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7321 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7322 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7323 * TMath::RadToDeg();
7324 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7325 45.-ssdpconemiddleholeangle,2);
7326 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7327 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7328 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7329 ssdpconelittlehole[3]->SetLineColor(4);
7330 TGeoRotation* ssdconemiddleholerot[8];
7331 for(Int_t i=0; i<8; i++){
7332 ssdconemiddleholerot[i] = new TGeoRotation();
7333 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7334 }
7335 /////////////////////////////////////////////////////////////
7336 ssdpconezsection[8] = ssdpconezsection[7];
7337 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7338 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7339 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7340 * CosD(fgkSSDPConeAngle)
7341 / SinD(fgkSSDPConeAngle);
7342 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7343 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7344 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7345 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7346 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7347 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7348 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7349 ssdpconelittlehole[4]->SetLineColor(4);
7350 /////////////////////////////////////////////////////////////
7351 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7352 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7353 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7354 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7355 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7356 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7357 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7358 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7359 * TMath::RadToDeg();
7360 ssdpconezsection[10] = ssdpconezsection[9];
7361 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7362 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7363 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7364 * CosD(fgkSSDPConeAngle)
7365 / SinD(fgkSSDPConeAngle);
7366 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7367 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7368 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7369 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7370 ssdpconetrapezoidsectionangle,2);
7371 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7372 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7373 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7374 ssdpconelittlehole[5]->SetLineColor(4);
7375 TGeoRotation* ssdconeupradiusrot[8];
7376 for(Int_t i=0; i<8; i++){
7377 ssdconeupradiusrot[i] = new TGeoRotation();
7378 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7379 }
7380 /////////////////////////////////////////////////////////////
7381 ssdpconezsection[12] = ssdpconezsection[11];
7382 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7383 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7384 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7385 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7386 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7387 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7388 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7389 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7390 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7391 ssdpconelittlehole[6]->SetLineColor(4);
7392 /////////////////////////////////////////////////////////////
7393 ssdpconezsection[14] = 0.0;
7394 ssdpconezsection[15] = ssdpconezsection[0];
7395 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7396 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7397 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7398 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7399 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7400 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7401 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7402 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7403 ssdpconelittlehole[7]->SetLineColor(4);
7404 /////////////////////////////////////////////////////////////
7405 TGeoTube* ssdtubeconeshape[2];
7406 TGeoVolume* ssdtubecone[2];
7407 TGeoTranslation* ssdtubeconetrans[2];
7408 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7409 fgkSSDPConeExternalRadius,
7410 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7411 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7412 0.5*ssdpconezsection[0]);
7413 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7414 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7415 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7416 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7417 + ssdpconezsection[13]);
7418 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7419 ssdtubecone[0]->SetLineColor(4);
7420 ssdtubecone[1]->SetLineColor(4);
7421 /////////////////////////////////////////////////////////////
7422 // Mother Volume Container
7423 /////////////////////////////////////////////////////////////
7424 Double_t ssdconemotherradiusmin[8];
7425 Double_t ssdconemotherradiusmax[8];
7426 Double_t ssdconemothersection[8];
7427 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7428 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7429 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7430 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7431 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7432 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7433 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7434 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7435 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7436 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7437 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7438 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7439 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7440 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7441 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7442 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7443 ssdconemothersection[0] = 0.0;
7444 ssdconemothersection[1] = ssdpconezsection[0];
7445 ssdconemothersection[2] = ssdpconezsection[0];
7446 ssdconemothersection[3] = ssdpconezsection[11];
7447 ssdconemothersection[4] = ssdpconezsection[11];
7448 ssdconemothersection[5] = ssdpconezsection[13];
7449 ssdconemothersection[6] = ssdpconezsection[13];
7450 ssdconemothersection[7] = fgkSSDPConeLength;
7451 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7452 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7453 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7454 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7455 /////////////////////////////////////////////////////////////
7456 //Placing the Volumes into Mother
7457 /////////////////////////////////////////////////////////////
7458 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7459 for(Int_t i=0; i<6; i++){
7460 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7461 }
7462 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7463 for(Int_t i=0; i<8; i++){
7464 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7465 }
7466 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7467 for(Int_t i=0; i<8; i++){
7468 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7469 }
7470 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7471 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7472 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7473 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7474 /////////////////////////////////////////////////////////////
7475 // ITS General Support
7476 /////////////////////////////////////////////////////////////
7477 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7478 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7479 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7480 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7481 - fgkSSDCentralAL3SupportLength);
7482 ssdcentralsupport->SetLineColor(4);
7483 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7484 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7485 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7486 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7487 TGeoTranslation* ssdcentralal3supportrans[3];
7488 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7489 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7490 - 1.25*fgkSSDCentralAL3SupportLength);
7491 ssdcentralal3support->SetLineColor(4);
7492 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7493 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7494 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7495 Double_t ssdpconcentralradiusmin[2];
7496 Double_t ssdpconcentralradiusmax[2];
7497 Double_t ssdpconcentralsection[2];
7498 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7499 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7500 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7501 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7502 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7503 ssdpconcentralsection[1] = 0.;
7504 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7505 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7506 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7507 ssdpconcentralal3->SetLineColor(4);
7508 fSSDCone->AddNode(ssdpconcentralal3,1);
7509 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7510 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7511 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7512 -2.*fgkSSDCentralAL3SupportLength);
7513 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7514 *ssdcentralal3supportrot);
7515 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7516 TGeoRotation* ssdconemotherot = new TGeoRotation();
7517 ssdconemotherot->SetAngles(90.,180.,-90.);
7518 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7519 -2.*fgkSSDCentralAL3SupportLength);
7520 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7521 fSSDCone->AddNode(ssdconemother,1);
7522 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7523 /////////////////////////////////////////////////////////////
7524 // Deallocating memory
7525 /////////////////////////////////////////////////////////////
7526 delete ssdcentralal3supportrot;
7527 delete ssdcentralal3supportrans[2];
7528 delete ssdconemotherot;
7529 delete ssdconemothertrans;
7530 /////////////////////////////////////////////////////////////
7531 }
fcfbdd23 7532 ////////////////////////////////////////////////////////////////////////////////
7533 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7534 /////////////////////////////////////////////////////////////
7535 // Setting SSD Cables
7536 /////////////////////////////////////////////////////////////
7537 if (! moth) {
7538 printf("Error::AliITSv11GeometrySSD: Can't insert SSD Cables, mother is null!\n");
7539 return;
7540 };
7541 TGeoVolume* ssdcables = SetSSDCables();
7542 moth->AddNode(ssdcables,1);
7543}
47f8de53 7544 ////////////////////////////////////////////////////////////////////////////////
7545 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7546 /////////////////////////////////////////////////////////////
7547 // Method generating SSDCables
7548 /////////////////////////////////////////////////////////////
7549 // SSD Layer 5 Cables
7550 //////////////////////////////////////////////////////////////////////////////////////////////////
7551 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7552 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
fcfbdd23 7553 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
47f8de53 7554 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7555 //////////////////////////////////////////////////////////////////////////////////////////////////
7556 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+fgkSSDCablesLay5TubeRadiusMin;
7557 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7558 - fgkSSDLowerPConeRadius)
7559 * TanD(fgkSSDPConeAngle);
7560 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7561 + fgkEndCapSupportCenterLay5Position
7562 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7563 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7564 - ssdcableslay5startconedistance;
7565 ssdcablelay5rightsidelength *= ssdcablesfactor;
7566 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+fgkSSDCablesLay5RightSideHeight;
7567 TGeoTube* ssdcablelay5rightubeshape = new TGeoTube(ssdcableslay5rigthsideradiusmin,
7568 ssdcableslay5rightsideradiusmax,
7569 0.5*ssdcablelay5rightsidelength);
7570 TGeoVolume* ssdcablelay5righttube = new TGeoVolume("SSDCableLay5RightSideTube",
7571 ssdcablelay5rightubeshape,
7572 fSSDCopper);
7573 ssdcablelay5righttube->SetLineColor(9);
7574 TGeoTranslation* ssdcablelay5rightrans =
7575 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7576 + fgkEndCapSupportCenterLay5Position
7577 + 0.5*ssdcablelay5rightsidelength);
7578 ////////////////////////////////////
7579 // Double_t cablescapacity[20];
7580 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7581 ////////////////////////////////////
7582 ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7583 ////////////////////////////////////
7584 // TGeoPCone Volumes
7585 ///////////////////////////////////
7586 TGeoPcon* ssdcableslay5pconshape[3];
7587 TGeoVolume* ssdcableslay5pcon[3];
7588 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7589 Double_t ssdcableslay5pconzsection[6];
7590 Double_t ssdcableslay5pconrmin[6];
7591 Double_t ssdcableslay5pconrmax[6];
7592 ssdcableslay5pconrmin[0] = ssdcablelay5rightubeshape->GetRmin();
7593 ssdcableslay5pconrmax[0] = ssdcablelay5rightubeshape->GetRmax();
7594 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7595 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+fgkSSDCablesLay5RightSideHeight;
7596 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7597 + fgkEndCapSupportCenterLay5Position
7598 + 2.*ssdcablelay5rightubeshape->GetDz();
7599 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7600 + fgkSSDCentralAL3SupportLength
7601 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7602 * TanD(fgkSSDPConeAngle);
7603 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7604 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7605 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7606 ssdcableslay5pconshape[0],fSSDCopper);
7607 ssdcableslay5pcon[0]->SetLineColor(9);
7608 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7609////////////////////////////////////
7610// cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7611////////////////////////////////////
7612 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7613 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7614 + fgkSSDCentralAL3SupportLength
7615 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7616 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7617 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7618 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7619 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7620 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7621 ssdcableangle,2);
7622 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7623 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7624 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7625 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7626 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7627 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3]+fgkSSDCablesLay5RightSideHeight;
7628 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7629 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7630 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7631 ssdcableslay5pcon[1]->SetLineColor(9);
7632 ////////////////////////////////////
7633 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7634 ssdcableangle,2);
7635 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7636 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7637 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7638 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7639 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7640 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7641 * TanD(fgkSSDPConeAngle)
7642 + 0.5*fgkSSDCentralSupportLength
7643 + fgkSSDCentralAL3SupportLength;
7644 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7645 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7646 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7647 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7648 ssdcableslay5pcon[2]->SetLineColor(9);
7649////////////////////////////////////
7650 TGeoRotation* ssdcableslay5pconrot[4];
7651 for(Int_t i=0; i<4; i++){
7652 ssdcableslay5pconrot[i] = new TGeoRotation();
7653 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7654 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7655 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
7656 }
7657 ////////////////////////////////////
7658 //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7659 //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7660 ////////////////////////////////////
7661 // Positioning Left SSD Cables Part
7662 ////////////////////////////////////
7663 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7664 - 0.5*ssdcablelay5rightsidelength
7665 - fgkEndCapSupportCenterLay5Position
7666 - fgkEndCapSupportCenterLay5ITSPosition);
7667 ssdcablesmother->AddNode(ssdcablelay5righttube,2,ssdcablesLay5RightTubeToLeftrans);
7668 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7669 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7670 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7671 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7672 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7673 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7674 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7675 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7676 }
7677 ////////////////////////////////////
7678 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7679 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7680 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7681 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7682 /////////////////////////////////////////////////////////////
7683 // Water Tubes Layer 5
7684 /////////////////////////
7685 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7686 ssdcableslay5rightsideradiusmax
7687 + fgkSSDCablesLay5RightSideWaterHeight,
7688 0.5*ssdcablelay5rightsidelength);
7689 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7690 ssdcablelay5rightubewatershape,
7691 fSSDCoolingTubeWater);
7692 ssdcablelay5rightwatertube->SetLineColor(7);
7693 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7694 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7695 ////////////////////////////////////
7696 // TGeoPCone Water Volumes Layer
7697 ///////////////////////////////////
7698 TGeoPcon* ssdcableslay5pconwatershape[3];
7699 TGeoVolume* ssdcableslay5pconwater[3];
7700 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7701 Double_t ssdcableslay5pconwaterzsection[6];
7702 Double_t ssdcableslay5pcwateronrmin[6];
7703 Double_t ssdcableslay5pconwaterrmax[6];
7704 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7705 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7706 + fgkSSDCablesLay5RightSideWaterHeight;
7707 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7708 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7709 + fgkSSDCablesLay5RightSideWaterHeight;
7710 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7711 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7712 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7713 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7714 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7715 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7716 ssdcableslay5pconwater[0]->SetLineColor(7);
7717 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7718 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7719////////////////////////////////////
7720 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7721 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7722 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7723 ssdcableangle,2);
7724 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7725 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7726 + fgkSSDCablesLay5RightSideWaterHeight;
7727 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7728 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7729 + fgkSSDCablesLay5RightSideWaterHeight;
7730 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7731 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7732 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7733 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7734 ssdcableslay5pconwater[1]->SetLineColor(7);
7735////////////////////////////////////
7736 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7737 ssdcableangle,2);
7738 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7739 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7740 + fgkSSDCablesLay5RightSideWaterHeight;
7741 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7742 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7743 + fgkSSDCablesLay5RightSideWaterHeight;
7744 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7745 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7746 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7747 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7748 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7749 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7750 ssdcableslay5pconwater[2]->SetLineColor(7);
7751////////////////////////////////////
7752 TGeoRotation* ssdcableslay5pconwaterot[4];
7753 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7754 for(Int_t i=0; i<4; i++){
7755 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7756 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7757 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7758 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7759 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7760 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7761 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7762 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7763 }
7764 /////////////////////////
7765 // SSD Layer 6 Cables
7766 /////////////////////////
7767 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+fgkSSDCablesLay6TubeRadiusMin;
7768 Double_t ssdcablelay6rightsidelength = 2.*ssdcablelay5rightsidelength;
7769 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+fgkSSDCablesLay6RightSideHeight;
7770 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7771 ssdcableslay6rightsideradiusmax,
7772 0.5*ssdcablelay6rightsidelength);
7773 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7774 ssdcablelay6rightubeshape,
7775 fSSDCopper);
7776 ssdcablelay6righttube->SetLineColor(9);
7777 TGeoTranslation* ssdcablelay6rightrans =
7778 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7779 + fgkEndCapSupportCenterLay6Position
7780 + 0.5*ssdcablelay6rightsidelength);
7781 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7782 - 0.5*ssdcablelay6rightsidelength
7783 - fgkEndCapSupportCenterLay6Position
7784 - fgkEndCapSupportCenterLay6ITSPosition);
7785 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7786 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7787 ////////////////////////////////////
7788 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7789 ////////////////////////////////////
7790 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7791 ssdcableangle,2);
7792 TGeoVolume* ssdcableslay6pcon;
7793 Double_t ssdcableslay6pconrmin[2];
7794 Double_t ssdcableslay6pconrmax[2];
7795 Double_t ssdcableslay6pconzsection[2];
7796 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7797 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7798 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7799 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7800 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7801 + fgkEndCapSupportCenterLay6Position
7802 + ssdcablelay6rightsidelength;
7803 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7804 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7805 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7806 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7807 ssdcableslay6pconshape,fSSDCopper);
7808 ssdcableslay6pcon->SetLineColor(9);
7809 for(Int_t i=0; i<4; i++){
7810 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7811 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7812 }
7813 ////////////////////////////////////
7814 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7815 /////////////////////////
7816 // Water Tubes Layer 6
7817 /////////////////////////
7818 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7819 ssdcableslay6rightsideradiusmax
7820 + fgkSSDCablesLay5RightSideWaterHeight,
7821 0.5*ssdcablelay6rightsidelength);
7822 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7823 ssdcablelay6righwatertubeshape,
7824 fSSDCoolingTubeWater);
7825 ssdcablelay6rightwatertube->SetLineColor(7);
7826 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7827 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7828 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7829 ssdcableangle,2);
7830 TGeoVolume* ssdcableslay6waterpcon;
7831 Double_t ssdcableslay6waterpconrmin[2];
7832 Double_t ssdcableslay6waterpconrmax[2];
7833 Double_t ssdcableslay6waterpconzsection[2];
7834 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7835 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7836 + fgkSSDCablesLay5RightSideWaterHeight;
7837 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7838 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7839 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7840 + fgkEndCapSupportCenterLay6Position
7841 + ssdcablelay6rightsidelength;
7842 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7843 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7844 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7845 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7846 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7847 ssdcableslay6waterpcon->SetLineColor(7);
7848 TGeoRotation* ssdcableslay6pconwaterot[4];
7849 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7850 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7851 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7852 for(Int_t i=0; i<4; i++){
7853 ssdcableslay6pconwaterot[i] = new TGeoRotation();
7854 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7855 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7856 * (*ssdcableslay6pconwaterot[i]));
7857 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7858 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7859 }
7860 ////////////////////////////////////////
7861 // From ITS Ring to Patch Panel3-RB26
7862 ////////////////////////////////////////
7863 Double_t ssdcablepatchpanel3BB26radiusmin[2];
7864 Double_t ssdcablepatchpanel3BB26radiusmax[2];
7865 Double_t ssdcablepatchpanel3RB26zsection[2];
fcfbdd23 7866 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeigth+2.8;
47f8de53 7867 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
7868 + fgkSSDCablesLay5RightSideHeight
7869 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
7870 ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
7871 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
7872 + 0.*fgkSSDCablesLay5RightSideHeight
7873 + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
7874 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
7875 + fgkSSDCentralAL3SupportLength
7876 + fgkSSDPConeZLength[0];
7877 ssdcablepatchpanel3RB26zsection[1] = fgkSSDPatchPanel2RB26ITSDistance;
7878 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
7879 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7880 - 0.5*ssdcableangle,ssdcableangle,2);
7881 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7882 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7883 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7884 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7885 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
7886 TGeoRotation* ssdcablepatchpanel3B26rot[3];
7887 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
7888 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
7889 ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
7890 + fgkSSDCablesPatchPanel2RB26Angle[1],0.0,0.0);
7891 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
7892 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0]
7893 + fgkSSDCablesPatchPanel2RB26Angle[1],0.0,0.0);
7894 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
7895 ////////////////////////////////////
7896 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7897 ////////////////////////////////////////
7898 // ITS Ring Cables RB26 Part
7899 ////////////////////////////////////////
7900 Double_t ssdcableitsring3BB26pconzsection[2];
7901 Double_t ssdcableitsring3BB26pconrmin[2];
7902 Double_t ssdcableitsring3BB26pconrmax[2];
7903 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7904 + fgkSSDCentralAL3SupportLength
7905 + (4.0/5.0)*fgkSSDPConeZLength[0];
7906 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
7907 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeigth;
7908 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
7909 + fgkSSDCablesLay5RightSideHeight
7910 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
7911 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7912 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7913 TGeoPcon* ssdcableitsring3BB26pconshape[4];
7914 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7915 - 0.5*ssdcableangle,ssdcableangle
7916 + (fgkSSDCablesPatchPanel2RB26Angle[0]
7917 - fgkSSDCableAngle),2);
7918 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7919 - 0.5*ssdcableangle,ssdcableangle
7920 + 3.0*fgkSSDCableAngle
7921 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7922 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-fgkSSDCablesPatchPanel2RB26Angle[0]
7923 - 0.5*ssdcableangle,ssdcableangle
7924 - fgkSSDCableAngle
7925 + fgkSSDCablesPatchPanel2RB26Angle[0],2);
7926 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7927 - 0.5*ssdcableangle,ssdcableangle
7928 + 3.0*fgkSSDCableAngle
7929 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7930 for(Int_t i=0;i<4;i++)
7931 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7932 ssdcableitsring3BB26pconrmin[j],
7933 ssdcableitsring3BB26pconrmax[j]);
7934 TGeoVolume* ssdcableitsring3BB26pcon[4];
7935 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7936 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7937 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7938 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7939 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7940 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7941 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7942 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7943 for(Int_t i=0;i<4;i++){
7944 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
7945 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],i+1);
7946}
7947 ////////////////////////////////////
7948 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7949 // + ssdcableitsring3BB26pconshape[1]->Capacity()
7950 // + ssdcableitsring3BB26pconshape[2]->Capacity()
7951 // + ssdcableitsring3BB26pconshape[3]->Capacity();
7952 ////////////////////////////////////////
7953 // From ITS Ring to Patch Panel2-RB24
7954 ////////////////////////////////////////
7955 Double_t ssdcablepatchpanel3BB24radiusmin[2];
7956 Double_t ssdcablepatchpanel3BB24radiusmax[2];
7957 Double_t ssdcablepatchpanel3RB24zsection[2];
7958 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7959 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
7960 ssdcablepatchpanel3BB24radiusmin[1] = fgkSSDPatchPanel2RB24Radius;
7961 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
7962 + 0.*fgkSSDCablesLay5RightSideHeight
7963 + 0.*fgkSSDCablesLay6RightSideHeight
7964 + 0.5*fgkSSDPatchPanelHeigth;
7965 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7966 - fgkSSDCentralAL3SupportLength
7967 - fgkSSDPConeZLength[0];
7968 ssdcablepatchpanel3RB24zsection[1] = -fgkSSDPatchPanel2RB24ITSDistance;
7969 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
7970 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7971 - 0.5*ssdcableangle,ssdcableangle,2);
7972 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7973 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7974 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7975 ssdcablepatchpanel3RB24pconshape,
7976 fSSDCopper);
7977 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
7978 TGeoRotation* ssdcablepatchpanel3B24rot[3];
7979 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
7980 ssdcablepatchpanel3B24rot[0]->SetAngles(0.0,0.0,0.0);
7981 ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0]
7982 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7983 ssdcablepatchpanel3B24rot[2]->SetAngles(180.0,0.0,0.0);
7984 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0]
7985 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7986 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
7987 ////////////////////////////////////
7988 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7989 ////////////////////////////////////////
7990 // ITS Ring Cables RB24 Part
7991 ////////////////////////////////////////
7992 Double_t ssdcableitsring3BB24pconzsection[2];
7993 Double_t ssdcableitsring3BB24pconrmin[2];
7994 Double_t ssdcableitsring3BB24pconrmax[2];
7995 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7996 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
7997 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeigth;
7998 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
7999 + fgkSSDCablesLay5RightSideHeight
8000 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
8001 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
8002 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
8003 TGeoPcon* ssdcableitsring3BB24pconshape[4];
8004 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
8005 + (90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
8006 - fgkSSDCableAngle),2);
8007 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+fgkSSDCableAngle-0.5*ssdcableangle,
8008 ssdcableangle-fgkSSDCableAngle
8009 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
8010 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
8011 - fgkSSDCableAngle
8012 + 90.0-fgkSSDCablesPatchPanel2RB24Angle[1],2);
8013 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle,
8014 ssdcableangle-fgkSSDCableAngle
8015 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
8016 for(Int_t i=0;i<4;i++)
8017 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
8018 ssdcableitsring3BB24pconrmin[j],
8019 ssdcableitsring3BB24pconrmax[j]);
8020 TGeoVolume* ssdcableitsring3BB24pcon[4];
8021 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
8022 ssdcableitsring3BB24pconshape[0],fSSDCopper);
8023 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
8024 ssdcableitsring3BB24pconshape[1],fSSDCopper);
8025 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
8026 ssdcableitsring3BB24pconshape[2],fSSDCopper);
8027 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
8028 ssdcableitsring3BB24pconshape[3],fSSDCopper);
8029 for(Int_t i=0;i<4;i++){
8030 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
8031 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],i+1);
8032}
8033 ////////////////////////////////////
8034 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
8035 // + ssdcableitsring3BB24pconshape[1]->Capacity()
8036 // + ssdcableitsring3BB24pconshape[2]->Capacity()
8037 // + ssdcableitsring3BB24pconshape[3]->Capacity();
8038 ////////////////////////////////////
8039 // Volumes for Material Budget
8040 ////////////////////////////////////
8041 TGeoTube* ssdcablelay6materialbudgetubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax
8042 + fgkSSDCablesLay5RightSideWaterHeight,
8043 ssdcableslay6rightsideradiusmax
8044 + fgkSSDCablesLay5RightSideWaterHeight
8045 + fgkSSDCableMaterialBudgetHeight,0.5*ssdcablelay6rightsidelength);
8046 TGeoVolume* ssdcablelay6materialbudgetube = new TGeoVolume("SSDCableLay6MaterialBudgetTube",
8047 ssdcablelay6materialbudgetubeshape,
8048 fSSDCopper);
8049 ssdcablelay6materialbudgetube->SetLineColor(9);
8050 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,1,ssdcablelay6rightrans);
8051 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,2,ssdcablesLay6RightTubeToLeftrans);
8052
8053 TGeoPcon* ssdcablelay6materialbudgetpconshape =
8054 new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
8055 TGeoVolume* ssdcablelay6materialbudgetpcon;
8056 Double_t ssdcablelay6materialbudgetpconrmin[2];
8057 Double_t ssdcablelay6materialbudgetpconrmax[2];
8058 Double_t ssdcablelay6materialbudgetpconzsection[2];
8059 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
8060 + fgkSSDCablesLay5RightSideWaterHeight;
8061 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
8062 + fgkSSDCableMaterialBudgetHeight;
8063 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
8064 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
8065 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
8066 + fgkEndCapSupportCenterLay6Position
8067 + ssdcablelay6rightsidelength;
8068 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
8069 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
8070 ssdcablelay6materialbudgetpconzsection[i],
8071 ssdcablelay6materialbudgetpconrmin[i],
8072 ssdcablelay6materialbudgetpconrmax[i]);
8073 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
8074 ssdcablelay6materialbudgetpconshape,fSSDCopper);
8075 ssdcablelay6materialbudgetpcon->SetLineColor(9);
8076 for(Int_t i=0; i<4; i++){
8077 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
8078 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
8079 }
8080////////////////////////////////////
8081 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
8082 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
8083 Double_t ssdcablesvolume = 0.0;
8084 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
8085 std::cout << ssdcablesvolume << std::endl;*/
8086 return ssdcablesmother;
8087 }
8088 ////////////////////////////////////////////////////////////////////////////////
d7599219 8089TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
44285dfa 8090 Double_t height, char* shapename, Int_t isign) const{
8091 /////////////////////////////////////////////////////////////
8092 // Method generating an Arb shape
8093 /////////////////////////////////////////////////////////////
8094 const Int_t kvertexnumber = 8;
8095 const Int_t ktransvectnumber = 2;
8096 TVector3* vertex[kvertexnumber];
8097 TVector3* transvector[2];
8098 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
8099 /////////////////////////////////////////////////////////////
d7599219 8100 //Setting the vertices for TGeoArb8
44285dfa 8101 /////////////////////////////////////////////////////////////
8102 vertex[0] = new TVector3(*vertexpos[0]);
8103 vertex[1] = new TVector3(*vertexpos[1]);
8104 vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
8105 vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
8106 vertex[4] = new TVector3(*vertexpos[2]);
8107 vertex[5] = new TVector3(*vertexpos[3]);
8108 vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
8109 vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
8110 /////////////////////////////////////////////////////////////
8111 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
8112 for(Int_t i = 0; i<kvertexnumber;i++)
8113 arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
bf210566 8114 /////////////////////////////////////////////////////////////
8115 // Deallocating memory
8116 /////////////////////////////////////////////////////////////
8117 for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
8118 for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
8119 /////////////////////////////////////////////////////////////
44285dfa 8120 return arbshape;
d7599219 8121}
bf210566 8122///////////////////////////////////////////////////////////////////////////////
8123TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8124 Double_t rmax, Int_t nedges, Double_t height){
8125 /////////////////////////////////////////////////////////////
8126 // Method generating Arc shape
8127 /////////////////////////////////////////////////////////////
8128 const Int_t kvertexnumber = 2*nedges+2;
8129 TGeoXtru* arcshape = new TGeoXtru(2);
8130 TVector3** vertexposition[2];
8131 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8132 Double_t angle = 0.;
8133 for(Int_t i=0; i<nedges+1; i++){
8134 angle = 90.+0.5*phi-i*(phi/nedges);
8135 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
8136 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
8137 }
8138 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8139 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8140 for(Int_t i=0; i<kvertexnumber; i++){
8141 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8142 yvertexpoints[i] = vertexposition[0][i]->Y();
8143 }
8144 else if(i>=1&&i<nedges+2)
8145 {
8146 xvertexpoints[i] = vertexposition[1][i-1]->X();
8147 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8148 }
8149 else
8150 {
8151 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8152 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8153 }
8154 }
8155 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8156 arcshape->DefineSection(0,-0.5*height);
8157 arcshape->DefineSection(1,0.5*height);
44285dfa 8158 /////////////////////////////////////////////////////////////
bf210566 8159 // Deallocating memory
44285dfa 8160 /////////////////////////////////////////////////////////////
bf210566 8161 for(Int_t i=0; i<2; i++){
8162 for(Int_t j=0; j<nedges+1; j++)
8163 delete vertexposition[i][j];
8164 delete [] vertexposition[i];
8165 }
8166 delete [] xvertexpoints;
8167 delete [] yvertexpoints;
8168 /////////////////////////////////////////////////////////////
8169 return arcshape;
d7599219 8170}
8171////////////////////////////////////////////////////////////////////////////////
9b0c60ab 8172TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
8173 ///////////////////////////////////////////////////////////////////////
8174 // Method Generating the Screw Shape
8175 // radius[0]: outer radius
8176 // radius[1]: inner radius
8177 // edgesnumber[0]: outer number of edges
8178 // edgesnumber[1]: inner number of edges
8179 // section[0]: lower section position
8180 // section[1]: higher section position
8181 ///////////////////////////////////////////////////////////////////////
8182 Double_t outradius = radius[0];
8183 Double_t inradius = radius[1];
8184 Int_t outvertexnumber = edgesnumber[0];
8185 Int_t invertexnumber = edgesnumber[1];
8186 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
8187 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
8188 for(Int_t i=0; i<outvertexnumber+1; i++){
8189 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8190 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8191 }
8192 for(Int_t i=0; i<invertexnumber+1; i++){
8193 xscrewvertex[outvertexnumber+i+1] = inradius*CosD(90.-i*360./invertexnumber);
8194 yscrewvertex[outvertexnumber+i+1] = inradius*SinD(90.-i*360./invertexnumber);
8195 }
8196 TGeoXtru* screwshape = new TGeoXtru(2);
8197 screwshape->DefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex);
8198 screwshape->DefineSection(0,section[0]);
8199 screwshape->DefineSection(1,section[1]);
8200 delete [] xscrewvertex;
8201 delete [] yscrewvertex;
8202 return screwshape;
8203}
8204////////////////////////////////////////////////////////////////////////////////
8205TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
8206 ///////////////////////////////////////////////////////////////////////
8207 // Method Generating the Hole Shape
8208 // radius of the Hole
8209 // nedges: number of edges to approximate the circle
8210 ///////////////////////////////////////////////////////////////////////
8211 Int_t vertexnumber = nedges+6;
8212 Double_t* xholevertex = new Double_t[vertexnumber];
8213 Double_t* yholevertex = new Double_t[vertexnumber];
8214 xholevertex[0] = radius;
8215 xholevertex[1] = xholevertex[0];
8216 xholevertex[2] = -xholevertex[1];
8217 xholevertex[3] = xholevertex[2];
8218 xholevertex[4] = xholevertex[0];
8219 yholevertex[0] = 0.;
8220 yholevertex[1] = -radius;
8221 yholevertex[2] = yholevertex[1];
8222 yholevertex[3] = -yholevertex[1];
8223 yholevertex[4] = yholevertex[3];
8224 for(Int_t i=0; i<nedges+1; i++){
8225 xholevertex[i+5] = radius*CosD(i*360./nedges);
8226 yholevertex[i+5] = radius*SinD(i*360./nedges);
8227 }
8228 TGeoXtru* holeshape = new TGeoXtru(2);
8229 holeshape->DefinePolygon(vertexnumber,xholevertex,yholevertex);
8230 holeshape->DefineSection(0,section[0]);
8231 holeshape->DefineSection(1,section[1]);
8232 delete [] xholevertex;
8233 delete [] yholevertex;
8234 return holeshape;
8235}
8236////////////////////////////////////////////////////////////////////////////////
44285dfa 8237TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
8238 /////////////////////////////////////////////////////////////
8239 // Given an axis specified by param, it gives the reflection of the point
8240 // respect to the axis
8241 /////////////////////////////////////////////////////////////
8242 TVector3* n = new TVector3(param[0],param[1],param[2]);
8243 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8244 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 8245 /////////////////////////////////////////////////////////////
8246 // Deallocating memory
8247 /////////////////////////////////////////////////////////////
8248 delete n;
8249 /////////////////////////////////////////////////////////////
44285dfa 8250 return reflectedvector;
d7599219 8251}
8252////////////////////////////////////////////////////////////////////////////////
bf210566 8253TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
d7599219 8254 Double_t dx,
8255 Double_t dy,
8256 Double_t dz) const{
44285dfa 8257 /////////////////////////////////////////////////////////////
d7599219 8258 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 8259 /////////////////////////////////////////////////////////////
bf210566 8260 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8261 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 8262 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 8263 hmatrix->SetTranslation(newvect);
8264 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8265 delete hmatrix;
8266 return matrix;
d7599219 8267}
8268////////////////////////////////////////////////////////////////////////////////
d7599219 8269TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 8270 /////////////////////////////////////////////////////////////
8271 // Method returning the Medium type
8272 /////////////////////////////////////////////////////////////
d7599219 8273 char ch[30];
8274 sprintf(ch, "ITS_%s",mediumName);
8275 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8276 if (! medium)
8277 printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
8278 return medium;
8279}
8280////////////////////////////////////////////////////////////////////////////////
d7599219 8281void AliITSv11GeometrySSD::CreateMaterials(){
8282///////////////////////////////////
8283// This part has to be modified
8284///////////////////////////////////
8285 ///////////////////////////////////
8286 // Silicon for Sensor
8287 ///////////////////////////////////
bf210566 8288 fSSDSensorMedium = GetMedium("SI$");
d7599219 8289 ///////////////////////////////////
8290 // Silicon Mixture for Sensor
8291 ///////////////////////////////////
44285dfa 8292 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8293 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 8294 ///////////////////////////////////
8295 // Stiffener Components Materials
8296 ///////////////////////////////////
bf210566 8297 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 8298 ///////////////////////////
8299 // Stiffener Connectors
8300 ///////////////////////////
bf210566 8301 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 8302 ////////////////////////////////
8303 // Stiffener 0603-1812 Capacitor
8304 ////////////////////////////////
bf210566 8305 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8306 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
d7599219 8307 ///////////////////////////
8308 // Stiffener Hybrid Wire
8309 ///////////////////////////
bf210566 8310 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 8311 ///////////////////////////
8312 // Al for Cooling Block
8313 ///////////////////////////
bf210566 8314 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 8315 //////////////////////////////////////////////////////
8316 // Kapton and Al for Chip Cable Flex and Ladder Cables
8317 //////////////////////////////////////////////////////
bf210566 8318 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8319 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8320 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8321 fSSDAlTraceFlexMedium = GetMedium("AL$");
8322 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8323 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 8324 /////////////////////////////////////////////////////////////////
8325 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8326 //////////////////////////////////////////////////////////////////
44285dfa 8327 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 8328 /////////////////////////////////////////////////////////////////
8329 // G10 for Detector Leg, TubeHolder
8330 //////////////////////////////////////////////////////////////////
44285dfa 8331 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8332 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8333 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8334 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 8335 /////////////////////////////////////////////////////////////////
8336 // Water and Phynox for Cooling Tube
8337 //////////////////////////////////////////////////////////////////
bf210566 8338 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 8339 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 8340 /////////////////////////////////////////////////////////////////////
9b0c60ab 8341 // Material for Support Rings
8342 /////////////////////////////////////////////////////////////////////
8343 fSSDSupportRingAl = GetMedium("AL$");
47f8de53 8344 fSSDRohaCellCone = GetMedium("ROHACELL$");
9b0c60ab 8345 /////////////////////////////////////////////////////////////////////
bf210566 8346 fSSDAir = GetMedium("SDD AIR$");
47f8de53 8347 fSSDCopper = GetMedium("COPPER$");
bf210566 8348 fCreateMaterials = kTRUE;
d7599219 8349}
8350/////////////////////////////////////////////////////////////////////