]> 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
Adding possibility to use custom Gain map for dEdx calculation (Marian)
[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySSD.cxx
CommitLineData
d7599219 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
5ef8864c 16/* $Id$ */
d7599219 17
18//*************************************************************************
19// SSD geometry, based on ROOT geometrical modeler
20//
21// Enrico Cattaruzza ecattar@ts.infn.it
22//*************************************************************************
23#include "TMath.h"
24#include "TGeoVolume.h"
d7599219 25#include "TGeoMatrix.h"
26#include <TGeoManager.h>
d7599219 27#include "TVector3.h"
28#include "TGeoArb8.h"
29#include "TList.h"
30#include "TGeoMatrix.h"
31#include "TGeoCompositeShape.h"
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] =
7708d5f3 433 {47.0*fgkmm,0.35*fgkmm};
9b0c60ab 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
7708d5f3 4649 - 2.*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
7708d5f3 4684 - 2.*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 }
0e8760e5 5062////////////////////////////////////////////////////////////////////////////////
5063// Start Corrections 13/06/08
5064////////////////////////////////////////////////////////////////////////////////
5065 char lowerladderpconsupportname[30];
5066 TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
5067 TGeoVolume* lowerladderpconsupport[fgklayernumber];
5068 Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
5069 Double_t lowerladderpconradiusmax[fgklayernumber];
5070 Double_t lowerladderpconradiusmin[fgklayernumber];
5071 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5072 lowerladdersupportrot->SetAngles(90.,180.,-90);
5073 for(Int_t i=0; i<fgklayernumber; i++){
5074 lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
5075 * TMath::Cos(theta[i]);
5076 lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeigth;
5077 }
5078 for(Int_t i=0; i<fgklayernumber; i++){
5079/////////////////////////// Modified Version ?///////////////////
5080 lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
5081 for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
5082 lowerladderpconezsection[j],lowerladderpconradiusmin[i],
5083 lowerladderpconradiusmax[i]);
5084 sprintf(lowerladderpconsupportname,"LowerLadderPConSupportNameLay%d",i+5);
5085 lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
5086 lowerladderpconsupport[i]->SetLineColor(fColorAl);
5087 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
5088 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
5089 }
5090////////////////////////////////////////////////////////////////////////////////
5091// End Corrections 13/06/08
5092////////////////////////////////////////////////////////////////////////////////
5093 /*char lowerladdersupportname[30];
9b0c60ab 5094 TGeoXtru* lowerladdersupportshape[fgklayernumber];
5095 TGeoVolume* lowerladdersupport[fgklayernumber];
5096 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
5097 lowerladdersupportrot->SetAngles(90.,180.,-90);
5098 for(Int_t i=0; i<fgklayernumber; i++){
5099 lowerladdersupportshape[i] = new TGeoXtru(2);
5100 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
5101 xmothervertex[i],ymothervertex[i]);
5102 lowerladdersupportshape[i]->DefineSection(0,0.);
5103 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
5104 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
5105 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
5106 lowerladdersupportshape[i],fSSDSupportRingAl);
5107 lowerladdersupport[i]->SetLineColor(fColorAl);
5108 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
5109 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
0e8760e5 5110 }*/
9b0c60ab 5111 /////////////////////////////////////////////////////////////
5112 // Deallocating memory
5113 /////////////////////////////////////////////////////////////
5114 for(Int_t i=0; i<fgklayernumber; i++){
5115 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
5116 delete ringsupportvertex[i][j];
5117 delete [] ringsupportvertex[i];
5118 }
5119 for(Int_t i=0; i<fgklayernumber; i++){
5120 delete [] xmothervertex[i];
5121 delete [] ymothervertex[i];
5122 }
5123 delete xmothervertex;
5124 delete ymothervertex;
5125 delete globalrot;
5126 for(Int_t i=0; i<fgklayernumber; i++){
5127 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
5128 delete laddersupportrot[i][j];
5129 delete [] laddersupportrot[i];
5130 }
5131 }
5132 ////////////////////////////////////////////////////////////////////////////////
5133 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
5134 /////////////////////////////////////////////////////////////
5135 // Method generating Endcap CoverPlate
5136 /////////////////////////////////////////////////////////////
5137 // Holes Definition
5138 ///////////////////
5139 Int_t nendcapcoverplateholedges = 30;
5140 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
5141 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
5142 0.5*fgkEndCapCoverPlateThickness};
5143 TGeoXtru* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
5144 nendcapcoverplateholedges,holesection);
5145 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 5146 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 5147 endcapcoverplatesmallhole->SetLineColor(6);
5148 TGeoXtru* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
5149 nendcapcoverplateholedges,holesection);
5150 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 5151 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 5152 endcapcoverplatebighole->SetLineColor(6);
5153 //////////////////////////
5154 // Screw Piece Definition
5155 //////////////////////////
5156 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
5157 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
5158 CosD(0.5*smallscrewangle),
5159 0.5*fgkEndCapCoverPlateThickness);
5160 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
5161 endcapsmallscrewpieceshape,
5162 fSSDCoolingTubePhynox);
5163 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
5164 ///////////////////
5165 // Box Definition
5166 ///////////////////
5167 TGeoBBox* endcapcoverplateboxshape[4];
5168 TGeoVolume* endcapcoverplatebox[4];
5169 Double_t boxorigin[5][3];
5170 boxorigin[0][0] = 0.;
5171 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
5172 boxorigin[0][2] = 0.;
5173
5174 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
5175 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
5176 boxorigin[1][2] = 0.;
5177
5178 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
5179 + fgkEndCapCoverPlateSmallHoleSeparation[1];
5180 boxorigin[2][1] = boxorigin[1][1];
5181 boxorigin[2][2] = 0.;
5182
5183 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
5184 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
5185 boxorigin[3][1] = boxorigin[1][1];
5186 boxorigin[3][2] = 0.;
5187
5188 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5189 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5190 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
5191 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5192
5193 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5194 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5195 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5196 + fgkEndCapCoverPlateSmallHoleRadius,
5197 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5198
5199 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5200 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5201 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5202 + fgkEndCapCoverPlateSmallHoleRadius,
5203 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5204
5205 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5206 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5207 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5208 + fgkEndCapCoverPlateSmallHoleRadius,
5209 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5210
5211 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 5212 fSSDAlCoolBlockMedium);
9b0c60ab 5213 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 5214 fSSDAlCoolBlockMedium);
9b0c60ab 5215 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 5216 fSSDAlCoolBlockMedium);
9b0c60ab 5217 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 5218 fSSDAlCoolBlockMedium);
9b0c60ab 5219 endcapcoverplatebox[0]->SetLineColor(6);
5220 endcapcoverplatebox[1]->SetLineColor(6);
5221 endcapcoverplatebox[2]->SetLineColor(6);
5222 endcapcoverplatebox[3]->SetLineColor(6);
5223 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5224 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5225 fgkEndCapCoverPlateSmallHoleRadius,
5226 0.5*fgkEndCapCoverPlateThickness,
5227 endcapfillingboxorigin);
5228 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 5229 fSSDAlCoolBlockMedium);
9b0c60ab 5230 endcapfillingbox->SetLineColor(6);
5231 ////////////////////////////
5232 // Contour Xtru Definition
5233 ////////////////////////////
5234 const Int_t kcontourvertexnumber = 10;
5235 Double_t xcontourvertex[kcontourvertexnumber];
5236 Double_t ycontourvertex[kcontourvertexnumber];
5237 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5238 xcontourvertex[1] = xcontourvertex[0];
5239 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5240 xcontourvertex[3] = xcontourvertex[2];
5241 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5242 xcontourvertex[5] = xcontourvertex[4];
5243 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5244 xcontourvertex[7] = xcontourvertex[6];
5245 xcontourvertex[8] = xcontourvertex[4];
5246 xcontourvertex[9] = xcontourvertex[8];
5247 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5248 - (kendcapcoverplatesmallholenumber[1]-1)
5249 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5250 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5251 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5252 ycontourvertex[2] = ycontourvertex[1];
5253 ycontourvertex[3] = ycontourvertex[0];
5254 ycontourvertex[4] = ycontourvertex[3];
5255 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5256 ycontourvertex[6] = ycontourvertex[5];
5257 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5258 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5259 + fgkEndCapCoverPlateSmallHoleRadius;
5260 ycontourvertex[8] = ycontourvertex[7];
5261 ycontourvertex[9] = ycontourvertex[0];
5262 TGeoXtru* contourshape = new TGeoXtru(2);
5263 contourshape->DefinePolygon(kcontourvertexnumber,xcontourvertex,ycontourvertex);
5264 contourshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5265 contourshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
e21cdd03 5266 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5267 fSSDAlCoolBlockMedium);
9b0c60ab 5268 contour->SetLineColor(6);
5269 /////////////////////////////
5270 // Hole Contour Xtru Definition
5271 ////////////////////////////
5272 const Int_t kholecontourvertexnumber = 10;
5273 Double_t xholecontourvertex[2][kcontourvertexnumber];
5274 Double_t yholecontourvertex[2][kcontourvertexnumber];
5275 xholecontourvertex[0][0] = xcontourvertex[0];
5276 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5277 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5278 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5279 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5280 + 0.5*(fgkEndCapCoverPlateLength[2]
5281 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5282 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5283 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5284 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5285 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5286 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5287 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5288
5289 yholecontourvertex[0][0] = ycontourvertex[1];
5290 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5291 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5292 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5293 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5294 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5295 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5296 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5297 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5298 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5299 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5300
5301 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5302 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5303 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5304 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5305 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5306 + 0.5*(fgkEndCapCoverPlateLength[2]
5307 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5308 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5309 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5310 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5311 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5312 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5313 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5314
5315 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5316 - fgkEndCapCoverPlateWidth[0]);
5317 yholecontourvertex[1][1] = ycontourvertex[0];
5318 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5319 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5320 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5321 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5322 - fgkEndCapCoverPlateWidth[0]
5323 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5324 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5325 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5326 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5327 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5328
5329 TGeoXtru* holecontourshape[2];
5330 holecontourshape[0] = new TGeoXtru(2);
5331 holecontourshape[0]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[0],
5332 yholecontourvertex[0]);
5333 holecontourshape[0]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5334 holecontourshape[0]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5335
5336 holecontourshape[1] = new TGeoXtru(2);
5337 holecontourshape[1]->DefinePolygon(kholecontourvertexnumber,xholecontourvertex[1],
5338 yholecontourvertex[1]);
5339 holecontourshape[1]->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5340 holecontourshape[1]->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5341
5342 TGeoVolume* holecontour[2];
e21cdd03 5343 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",holecontourshape[0],
5344 fSSDAlCoolBlockMedium);
9b0c60ab 5345 holecontour[0]->SetLineColor(6);
e21cdd03 5346 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",holecontourshape[1],
5347 fSSDAlCoolBlockMedium);
9b0c60ab 5348 holecontour[1]->SetLineColor(6);
5349 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5350 + fgkEndCapCoverPlateLength[2],0.,0.);
5351 TGeoTranslation* bigholetrans[3];
5352 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5353 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5354 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5355 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5356 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5357 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5358 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5359 /////////////////////////////////
5360 // Mother Volume Xtru Definition
5361 /////////////////////////////////
5362 const Int_t kmothervertexnumber = 12;
5363 Double_t xmothervertex[kmothervertexnumber];
5364 Double_t ymothervertex[kmothervertexnumber];
5365 xmothervertex[0] = xcontourvertex[0];
5366 xmothervertex[1] = xmothervertex[0];
5367 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5368 xmothervertex[3] = xmothervertex[2];
5369 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5370 xmothervertex[5] = xmothervertex[4];
5371 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5372 xmothervertex[7] = xmothervertex[6];
5373 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5374 + fgkEndCapCoverPlateLength[2];
5375 xmothervertex[9] = xmothervertex[8];
5376 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5377 xmothervertex[11] = xmothervertex[10];
5378
5379 ymothervertex[0] = ycontourvertex[0];
5380 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5381 ymothervertex[2] = ymothervertex[1];
5382 ymothervertex[3] = ycontourvertex[1];
5383 ymothervertex[4] = ymothervertex[3];
5384 ymothervertex[5] = ymothervertex[1];
5385 ymothervertex[6] = ymothervertex[5];
5386 ymothervertex[7] = ymothervertex[0];
5387 ymothervertex[8] = ymothervertex[7];
5388 ymothervertex[9] = ymothervertex[8]
5389 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5390 ymothervertex[10] = ymothervertex[9];
5391 ymothervertex[11] = ymothervertex[8];
5392 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5393 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5394 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5395 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5396 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5397 ////////////////////////////////////////
5398 // Adding Nodes
5399 ////////////////////////////////////////
5400// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5401 TGeoTranslation*** endcapcoverplatesmallholetrans;
5402 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5403 Double_t transx[4] = {0,
5404 fgkEndCapCoverPlateSmallHoleSeparation[0],
5405 fgkEndCapCoverPlateSmallHoleSeparation[0]
5406 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5407 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5408 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5409 Int_t index = 0;
5410 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5411 endcapcoverplatesmallholetrans[i] =
5412 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5413 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5414 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5415 endcapcoverplatesmallholetrans[i][j] =
5416 new TGeoTranslation(transx[i],
5417 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5418 if(index!=10){
5419 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5420 index,endcapcoverplatesmallholetrans[i][j]);
5421 mothercoverplate->AddNode(endcapsmallscrewpiece,
5422 index,endcapcoverplatesmallholetrans[i][j]);
5423 }
5424 if(j<kendcapcoverplatesmallholenumber[1]-1)
5425 mothercoverplate->AddNode(endcapcoverplatebox[0],
5426 index,endcapcoverplatesmallholetrans[i][j]);
5427 }
5428 }
5429 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5430 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5431 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5432 mothercoverplate->AddNode(endcapfillingbox,1);
5433 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5434 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5435 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5436 mothercoverplate->AddNode(holecontour[0],1);
5437 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5438 mothercoverplate->AddNode(holecontour[1],1);
5439 mothercoverplate->AddNode(contour,1);
5440 /////////////////////////////////
5441 return mothercoverplate;
5442 }
5443 ////////////////////////////////////////////////////////////////////////////////
5444 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5445 /////////////////////////////////////////////////////////////
5446 // Getting EndCap Cooling Tube
5447 /////////////////////////////////////////////////////////////
5448 TGeoTorus* endcapcoolingtubetorushape[5];
5449 TGeoVolume* endcapcoolingtubetorus[5];
5450 TGeoTube* endcapcoolingtubeshape[4];
5451 TGeoVolume* endcapcoolingtube[4];
5452 char endcapcoolingtubetorusname[30];
5453 char endcapcoolingtubename[30];
5454 TGeoTorus* endcapcoolingwatertubetorushape[5];
5455 TGeoVolume* endcapcoolingwatertubetorus[5];
5456 TGeoTube* endcapcoolingwatertubeshape[4];
5457 TGeoVolume* endcapcoolingwatertube[4];
5458 char endcapcoolingwatertubetorusname[30];
5459 char endcapcoolingwatertubename[30];
5460 for(Int_t i=0; i<5; i++){
5461 sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5462 sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5463 sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5464 sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5465 if(i==3){
5466 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5467 fgkEndCapCoolingTubeRadiusMin,
5468 fgkEndCapCoolingTubeRadiusMax,
5469 90.0,fgkEndCapCoolingTubeAngle[3]);
5470 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5471 0.,fgkEndCapCoolingTubeRadiusMin,
5472 90.0,fgkEndCapCoolingTubeAngle[3]);
5473 }
5474 else{
5475 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5476 :fgkEndCapCoolingTubeAxialRadius[1],
5477 fgkEndCapCoolingTubeRadiusMin,
5478 fgkEndCapCoolingTubeRadiusMax,
5479 0.,fgkEndCapCoolingTubeAngle[i]);
5480 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5481 :fgkEndCapCoolingTubeAxialRadius[1],
5482 0.,fgkEndCapCoolingTubeRadiusMin,
5483 0.,fgkEndCapCoolingTubeAngle[i]);
5484 }
5485 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5486 endcapcoolingtubetorushape[i],
5487 fSSDCoolingTubePhynox);
5488 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5489 endcapcoolingwatertubetorushape[i],
5490 fSSDCoolingTubeWater);
5491 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5492 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5493 if(i<4){
5494 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5495 fgkEndCapCoolingTubeRadiusMax,
5496 0.5*fgkEndCapCoolingTubeLength[i]);
5497 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5498 0.5*fgkEndCapCoolingTubeLength[i]);
5499 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5500 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5501 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5502 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5503 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5504 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5505 }
5506 }
5507 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5508 /////////////////////////////////////////
5509 // Transformation for Volume Positioning
5510 /////////////////////////////////////////
5511 TGeoCombiTrans* coolingtubecombitrans[6];
5512 TGeoRotation* coolingtuberot[8];
5513 TGeoTranslation* coolingtubetrans[6];
5514 TGeoHMatrix* coolingtubematrix[4];
5515 TGeoCombiTrans* torustubecombitrans[4];
5516 TGeoRotation* torustuberot[7];
5517 TGeoTranslation* torustubetrans[4];
5518 TGeoHMatrix* torustubematrix[5];
5519 TGeoCombiTrans* coolingwatertubecombitrans[6];
5520 TGeoRotation* coolingwatertuberot[8];
5521 TGeoTranslation* coolingwatertubetrans[6];
5522 TGeoHMatrix* coolingwatertubematrix[4];
5523 TGeoCombiTrans* toruswatertubecombitrans[4];
5524 TGeoRotation* toruswatertuberot[7];
5525 TGeoTranslation* toruswatertubetrans[4];
5526 TGeoHMatrix* toruswatertubematrix[5];
5527 for(Int_t i=0; i<8; i++){
5528 if(i<6){
5529 coolingtubetrans[i] = new TGeoTranslation();
5530 coolingwatertubetrans[i] = new TGeoTranslation();
5531 }
5532 if(i<8){
5533 coolingtuberot[i] = new TGeoRotation();
5534 coolingwatertuberot[i] = new TGeoRotation();
5535 }
5536 if(i<4){
5537 torustubetrans[i] = new TGeoTranslation();
5538 toruswatertubetrans[i] = new TGeoTranslation();
5539 }
5540 if(i<7){
5541 torustuberot[i] = new TGeoRotation();
5542 toruswatertuberot[i] = new TGeoRotation();
5543 }
5544 }
5545 /////////////////////////////////////////
5546 // Transformation for Inox Volume Positioning
5547 /////////////////////////////////////////
5548 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5549 -endcapcoolingtubeshape[0]->GetDz(),0.);
5550 coolingtuberot[0]->SetAngles(0.,90.,0.);
5551 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5552 *coolingtuberot[0]);
5553
5554 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5555 coolingtuberot[1]->SetAngles(0.,90.,0.);
5556 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5557 *coolingtuberot[1]);
5558
5559 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5560 *CosD(fgkEndCapCoolingTubeAngle[0]),
5561 fgkEndCapCoolingTubeAxialRadius[0]
5562 *SinD(fgkEndCapCoolingTubeAngle[0]),
5563 0.);
5564 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5565 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5566 *coolingtuberot[2]);
5567
5568 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5569 * (*coolingtubecombitrans[1]));
5570
5571 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5572 endcapcoolingtubeshape[1]->GetDz());
5573 torustuberot[0]->SetAngles(0.,90.,0.);
5574 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5575
5576 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5577
5578 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5579 -endcapcoolingtubeshape[2]->GetDz(),0.);
5580 coolingtuberot[3]->SetAngles(0.,90.,0.);
5581 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5582 *coolingtuberot[3]);
5583 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5584 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5585 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5586
5587 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5588 endcapcoolingtubeshape[2]->GetDz());
5589 torustuberot[1]->SetAngles(0.,90.,0.);
5590 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5591 torustuberot[2]->SetAngles(180.,0.,0.);
5592 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5593 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5594
5595 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5596 -fgkEndCapCoolingTubeAxialRadius[0]);
5597 torustuberot[3]->SetAngles(0.,90.,0.);
5598 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5599 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5600 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5601 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5602
5603 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5604 fgkEndCapCoolingTubeAxialRadius[0],0.);
5605 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5606 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5607 *coolingtuberot[5]);
5608 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5609 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5610 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5611
5612 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5613 endcapcoolingtubeshape[0]->GetDz());
5614 torustuberot[5]->SetAngles(0.,90.,0.);
5615 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5616 torustuberot[6]->SetAngles(-90.,0.,0.);
5617 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5618 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5619
5620 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5621 endcapcoolingtubeshape[3]->GetDz(),0.);
5622 coolingtuberot[6]->SetAngles(0.,90.,0.);
5623 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5624 *coolingtuberot[6]);
5625 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5626 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5627 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5628 /////////////////////////////////////////
5629 // Transformation for Water Volume Positioning
5630 /////////////////////////////////////////
5631 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5632 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5633 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5634 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5635 *coolingwatertuberot[0]);
5636
5637 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5638 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5639 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5640 *coolingwatertuberot[1]);
5641
5642 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5643 *CosD(fgkEndCapCoolingTubeAngle[0]),
5644 fgkEndCapCoolingTubeAxialRadius[0]
5645 *SinD(fgkEndCapCoolingTubeAngle[0]),
5646 0.);
5647 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5648 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5649 *coolingwatertuberot[2]);
5650
5651 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5652 * (*coolingwatertubecombitrans[1]));
5653
5654 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5655 endcapcoolingwatertubeshape[1]->GetDz());
5656 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5657 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5658 *toruswatertuberot[0]);
5659
5660 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5661 * (*toruswatertubecombitrans[0]));
5662
5663 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5664 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5665 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5666 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5667 *coolingwatertuberot[3]);
5668 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5669 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5670 * (*coolingwatertubecombitrans[3]));
5671 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5672
5673 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5674 endcapcoolingwatertubeshape[2]->GetDz());
5675 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5676 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5677 *toruswatertuberot[1]);
5678 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5679 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5680 * (*toruswatertubecombitrans[1]));
5681 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5682
5683 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5684 -fgkEndCapCoolingTubeAxialRadius[0]);
5685 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5686 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5687 *toruswatertuberot[3]);
5688 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5689 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5690 * (*toruswatertubecombitrans[2]));
5691 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5692
5693 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5694 fgkEndCapCoolingTubeAxialRadius[0],0.);
5695 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5696 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5697 *coolingwatertuberot[5]);
5698 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5699 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5700 * (*coolingwatertubecombitrans[4]));
5701 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5702
5703 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5704 endcapcoolingwatertubeshape[0]->GetDz());
5705 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5706 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5707 *toruswatertuberot[5]);
5708 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5709 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5710 * (*toruswatertubecombitrans[3]));
5711 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5712
5713 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5714 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5715 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5716 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5717 *coolingwatertuberot[6]);
5718 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5719 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5720 * (*coolingwatertubecombitrans[5]));
5721 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5722 /////////////////////////////////////////
5723 // Positioning Volumes
5724 /////////////////////////////////////////
5725 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5726 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5727
5728 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5729 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5730
5731 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5732 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5733
5734 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5735 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5736
5737 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5738 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5739
5740 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5741 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5742
5743 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5744 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5745
5746 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5747 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5748
5749 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5750 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5751
5752 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5753 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5754 /////////////////////////////////////////////////////////////
5755 // Deallocating memory
5756 /////////////////////////////////////////////////////////////
5757 for(Int_t i=0; i<8; i++){
5758 if(i<6){
5759 delete coolingtubetrans[i];
5760 delete coolingwatertubetrans[i];
5761 if(i!=0){
5762 delete coolingtubecombitrans[i];
5763 delete coolingwatertubecombitrans[i];
5764 }
5765 }
5766 if(i<8){
5767 delete coolingtuberot[i];
5768 delete coolingwatertuberot[i];
5769 }
5770 if(i<4){
5771 delete torustubetrans[i];
5772 delete toruswatertubetrans[i];
5773 delete torustubecombitrans[i];
5774 delete toruswatertubecombitrans[i];
5775 }
5776 if(i<7){
5777 delete torustuberot[i];
5778 delete toruswatertuberot[i];
5779 }
5780 }
5781 /////////////////////////////////////////////////////////////
5782 return endcapcoolingtubemother;
5783 }
5784 ////////////////////////////////////////////////////////////////////////////////
5785 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5786 /////////////////////////////////////////////////////////////
5787 // Getting EndCap Cover Side
5788 /////////////////////////////////////////////////////////////
5789 const Int_t kendcapcoverholenumber[2] = {7,5};
5790 const Int_t kvertexnumber = 15;
5791 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5792 xvertex[0] = 0.0;
5793 xvertex[1] = xvertex[0];
5794 xvertex[2] = fgkEndCapSideCoverLength[0];
5795 xvertex[3] = fgkEndCapSideCoverLength[1];
5796 xvertex[4] = xvertex[3];
5797 xvertex[5] = fgkEndCapSideCoverLength[2];
5798 xvertex[6] = xvertex[5];
5799 xvertex[7] = xvertex[2];
5800 xvertex[8] = xvertex[7];
5801 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5802 xvertex[10] = xvertex[9];
5803 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5804 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5805 * fgkEndCapSideCoverLength[4];
5806 xvertex[12] = xvertex[11];
5807 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5808 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5809 * fgkEndCapSideCoverLength[4];
5810 xvertex[14] = xvertex[13];
5811 yvertex[0] = 0.0;
5812 yvertex[1] = fgkEndCapSideCoverWidth[0];
5813 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5814 yvertex[3] = yvertex[2];
5815 yvertex[4] = fgkEndCapSideCoverWidth[1];
5816 yvertex[5] = yvertex[4];
5817 yvertex[6] = yvertex[0];
5818 yvertex[7] = yvertex[6];
5819 yvertex[8] = fgkEndCapSideCoverWidth[6];
5820 yvertex[9] = yvertex[8];
5821 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5822 yvertex[11] = yvertex[10];
5823 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5824 yvertex[13] = yvertex[12];
5825 yvertex[14] = yvertex[6];
5826 TGeoXtru* endcapsidecovershape = new TGeoXtru(2);
5827 endcapsidecovershape->DefinePolygon(kvertexnumber,xvertex,yvertex);
5828 endcapsidecovershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5829 endcapsidecovershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5830 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5831 endcapsidecovershape,fSSDCoolingTubePhynox);
5832 endcapsidecover->SetLineColor(fColorPhynox);
5833 ////////////////////////////////////////////
5834 // Defininition of Mother Volume
5835 ////////////////////////////////////////////
5836 const Int_t kmothervertexnumber = 7;
5837 Double_t xmothervertex[kmothervertexnumber];
5838 Double_t ymothervertex[kmothervertexnumber];
5839 for(Int_t i=0; i<kmothervertexnumber; i++){
5840 xmothervertex[i] = xvertex[i];
5841 ymothervertex[i] = yvertex[i];
5842 }
5843 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5844 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5845 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5846 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5847 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5848 endcapsidecovermothershape,fSSDAir);
5849 ////////////////////////////////////////////
5850 endcapsidecovermother->AddNode(endcapsidecover,1);
5851 TGeoBBox* endcapsidecoverboxshape[4];
5852 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5853 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5854 0.5*fgkEndCapSideCoverLength[4],
5855 0.5*fgkEndCapSideCoverThickness);
5856 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5857 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5858 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5859 - fgkEndCapSideCoverLength[4]),
5860 0.5*fgkEndCapSideCoverThickness);
5861 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5862 0.5*fgkEndCapSideCoverLength[4],
5863 0.5*fgkEndCapSideCoverThickness);
5864 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5865 0.5*fgkEndCapSideCoverWidth[5],
5866 0.5*fgkEndCapSideCoverThickness);
5867 TGeoVolume* endcapsidecoverbox[4];
5868 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5869 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5870 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5871 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5872 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5873// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5874 TGeoTranslation** endcapsidecoverboxtrans;
5875 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5876 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5877 + fgkEndCapSideCoverLength[0],
5878 endcapsidecoverboxshape[0]->GetDY()
5879 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5880 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5881 + xvertex[11],
5882 endcapsidecoverboxshape[1]->GetDY()
5883 + yvertex[12],0.);
5884 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5885 + xvertex[11],
5886 endcapsidecoverboxshape[2]->GetDY()
5887 + yvertex[12]
5888 + 2.*endcapsidecoverboxshape[1]->GetDY()
5889 + fgkEndCapSideCoverWidth[5],0.);
5890 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5891 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5892 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5893 for(Int_t i=0; i<2; i++)
5894 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5895 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5896 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5897 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5898 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5899 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5900 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5901 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5902 }
5903 for(Int_t i=0; i<2; i++)
5904 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5905 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5906 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5907 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5908 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5909 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5910 +fgkEndCapSideCoverLength[4]),0.0);
5911 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5912 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5913 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5914 +i*(kendcapcoverholenumber[1]-1)+j]);
5915 }
5916 return endcapsidecovermother;
5917 }
5918 ////////////////////////////////////////////////////////////////////////////////
5919 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5920 ////////////////////////////////////////////////////////////////////////////////
5921 // Method returning Interface Card A, Interface Card B, Supply Card
5922 ////////////////////////////////////////////////////////////////////////////////
5923 /////////////////////
5924 // Supply Card
5925 /////////////////////
5926 // Electronic Board Back Al Plane
5927 const Int_t kelectboardbackvertexnumber = 8;
5928 Double_t xelectboardback[kelectboardbackvertexnumber];
5929 Double_t yelectboardback[kelectboardbackvertexnumber];
5930 xelectboardback[0] = 0.0;
5931 xelectboardback[1] = xelectboardback[0];
5932 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5933 xelectboardback[3] = xelectboardback[2];
5934 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5935 xelectboardback[5] = xelectboardback[4];
5936 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5937 xelectboardback[7] = xelectboardback[6];
5938
5939 yelectboardback[0] = 0.0;
5940 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5941 yelectboardback[2] = yelectboardback[1];
5942 yelectboardback[3] = yelectboardback[0];
5943 yelectboardback[4] = yelectboardback[3];
5944 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5945 yelectboardback[6] = yelectboardback[5];
5946 yelectboardback[7] = yelectboardback[4];
5947 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5948 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5949 xelectboardback,yelectboardback);
5950 electboardbackshape->DefineSection(0,0.0);
5951 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5952 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5953 electboardbackshape,fSSDSupportRingAl);
5954 electboardback->SetLineColor(fColorAl);
5955 // Electronic Board Kapton Layer
5956 const Int_t kelectlayervertexnumber = 8;
5957 Double_t xelectlayer[kelectlayervertexnumber];
5958 Double_t yelectlayer[kelectlayervertexnumber];
5959 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5960 xelectlayer[1] = xelectlayer[0];
5961 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5962 xelectlayer[3] = xelectlayer[2];
5963 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5964
5965 yelectlayer[0] = 0.0;
5966 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5967 yelectlayer[2] = yelectlayer[1];
5968 yelectlayer[3] = yelectlayer[0];
5969 yelectlayer[4] = yelectlayer[3];
5970 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5971 yelectlayer[6] = yelectlayer[5];
5972 yelectlayer[7] = yelectlayer[4];
5973 TGeoXtru* electlayershape = new TGeoXtru(2);
5974 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5975 electlayershape->DefineSection(0,0.0);
5976 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5977 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5978 electlayershape,fSSDKaptonFlexMedium);
5979 electlayer->SetLineColor(fColorKapton);
5980 // JMD Connector Female
5981 const Int_t kjmdconnectorvertexnumber = 6;
5982 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5983 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5984 xjmdconnectorvertex[0] = 0.0;
5985 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5986 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5987 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5988 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5989 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5990
5991 yjmdconnectorvertex[0] = 0.0;
5992 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5993 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5994 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5995 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5996 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5997 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5998 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5999 yjmdconnectorvertex);
6000 jmdconnectorshape->DefineSection(0,0.0);
6001 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
6002 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
6003 jmdconnectorshape,fSSDMountingBlockMedium);
6004 jmdconnector->SetLineColor(fColorG10);
6005 // Top Cable Connector
6006 const Int_t kcableconnectorvertexnumber = 8;
6007 Double_t xconnectorvertex[kcableconnectorvertexnumber];
6008 Double_t yconnectorvertex[kcableconnectorvertexnumber];
6009 xconnectorvertex[0] = 0.0;
6010 xconnectorvertex[1] = xconnectorvertex[0];
6011 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
6012 xconnectorvertex[3] = xconnectorvertex[2];
6013 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
6014 - fgkEndCapCardCableConnectorLength[2];
6015 xconnectorvertex[5] = xconnectorvertex[4];
6016 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
6017 xconnectorvertex[7] = xconnectorvertex[6];
6018
6019 yconnectorvertex[0] = 0.0;
6020 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
6021 yconnectorvertex[2] = yconnectorvertex[1];
6022 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
6023 yconnectorvertex[4] = yconnectorvertex[3];
6024 yconnectorvertex[5] = yconnectorvertex[1];
6025 yconnectorvertex[6] = yconnectorvertex[5];
6026 yconnectorvertex[7] = yconnectorvertex[0];
6027 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
6028 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
6029 yconnectorvertex);
6030 cableconnectorshape->DefineSection(0,0.0);
6031 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
6032 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
6033 cableconnectorshape,fSSDMountingBlockMedium);
6034 cableconnector->SetLineColor(fColorG10);
6035 // Strip Connection
6036 TGeoBBox* endcapstripconnectionshape =
6037 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
6038 0.5*fgkEndCapStripConnectionThickness,
6039 0.5*fgkEndCapStripConnectionWidth);
6040 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
6041 endcapstripconnectionshape,
6042 fSSDSupportRingAl);
6043 endcapstripconnection->SetLineColor(fColorAl);
6044 // Interface Card B
6045 const Int_t kcardBvertexnumber = 12;
6046 Double_t xcardBvertexnumber[kcardBvertexnumber];
6047 Double_t ycardBvertexnumber[kcardBvertexnumber];
6048
6049 xcardBvertexnumber[0] = 0.0;
6050 xcardBvertexnumber[1] = xcardBvertexnumber[0];
6051 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
6052 xcardBvertexnumber[3] = xcardBvertexnumber[2];
6053 xcardBvertexnumber[4] = xcardBvertexnumber[1];
6054 xcardBvertexnumber[5] = xcardBvertexnumber[4];
6055 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
6056 xcardBvertexnumber[7] = xcardBvertexnumber[6];
6057 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
6058 xcardBvertexnumber[9] = xcardBvertexnumber[8];
6059 xcardBvertexnumber[10] = xcardBvertexnumber[7];
6060 xcardBvertexnumber[11] = xcardBvertexnumber[10];
6061
6062 ycardBvertexnumber[0] = 0.0;
6063 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
6064 ycardBvertexnumber[2] = ycardBvertexnumber[1];
6065 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
6066 ycardBvertexnumber[4] = ycardBvertexnumber[3];
6067 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
6068 ycardBvertexnumber[6] = ycardBvertexnumber[5];
6069 ycardBvertexnumber[7] = ycardBvertexnumber[4];
6070 ycardBvertexnumber[8] = ycardBvertexnumber[7];
6071 ycardBvertexnumber[9] = ycardBvertexnumber[1];
6072 ycardBvertexnumber[10] = ycardBvertexnumber[9];
6073 ycardBvertexnumber[11] = ycardBvertexnumber[0];
6074
6075 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
6076 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
6077 interfacecardBshape->DefineSection(0,0.);
6078 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
6079 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
6080 fSSDMountingBlockMedium);
6081 interfacecardB->SetLineColor(46);
6082 // Interface Card B Electronic Board
6083 const Int_t kelectboardcardBvertexnumber = 14;
6084 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
6085 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
6086
6087 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
6088 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
6089 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
6090 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
6091 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
6092 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
6093 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6094 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
6095 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6096 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
6097 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6098 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6099 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6100 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6101
6102 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6103 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6104 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
6105 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6106 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
6107 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
6108 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
6109 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6110 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
6111 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6112 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6113 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6114 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6115 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6116
6117 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6118 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6119 xelectboardcardBvertex,yelectboardcardBvertex);
6120 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6121 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6122 + fgkEndCapInterfaceElectBoardCardBThickness);
6123 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6124 fSSDSupportRingAl);
6125 electboardcardB->SetLineColor(fColorAl);
6126 // Generating Stiffener 2
6127 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6128 0.5*fgkEndCapStiffenerThickness,
6129 0.5*fgkEndCapStiffenerLength);
6130 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6131 endcapstiffener->SetLineColor(fColorAl);
6132 // Generating Mother Interface Card B Container
6133 const Int_t kinterfacecardBmothervertexnumber = 10;
6134 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6135 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6136
6137 xinterfacecardBmothervertex[0] = 0.0;
6138 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6139 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6140 + fgkEndCapInterfaceCardBThickness;
6141 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6142 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6143 + fgkEndCapInterfaceElectBoardCardBThickness;
6144 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6145 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6146 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6147 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6148 + fgkEndCapCardJMDConnectorLength[0];
6149 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6150
6151 yinterfacecardBmothervertex[0] = 0.0;
6152 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6153 + fgkEndCapInterfaceCardBWidth[1]
6154 + fgkEndCapInterfaceCardBWidth[2];
6155 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6156 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6157 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6158 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6159 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6160 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6161 + fgkEndCapCardJMDConnectorWidth[0]
6162 + fgkEndCapCardJMDConnectorWidth[1];
6163 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6164 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6165 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6166 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6167 xinterfacecardBmothervertex,
6168 yinterfacecardBmothervertex);
6169 interfacecardBmothershape->DefineSection(0,-1.e-15);
6170 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6171 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6172 interfacecardBmothershape,fSSDAir);
6173 electboardcardB->SetLineColor(fColorAl);
6174 // Positioning Volumes Mother Interface Card B Container
6175 TGeoRotation* interfacecardBrot = new TGeoRotation();
6176 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6177 interfacecardBrot->SetAngles(90.,-90.,-90.);
6178 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6179 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6180 TGeoRotation* electboardcardBrot = new TGeoRotation();
6181 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6182 electboardcardBrot->SetAngles(90.,90.,-90.);
6183 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6184 TGeoCombiTrans* electboardcardBcombitrans =
6185 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6186 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6187 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6188 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6189 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6190 TGeoTranslation* jmdconnectorcardBtrans[3];
6191 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6192 for(Int_t i=0; i<3; i++){
6193 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6194 + fgkEndCapCardJMDConnectorLength[0],
6195 fgkEndCapCardElectBoardLayerWidth[1],
6196 0.5*fgkEndCapCardJMDConnectorThickness
6197 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6198 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6199 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6200 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6201 *jmdconnectorcardBrot);
6202 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6203 }
6204 // Mother Supply Card Container
6205 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6206 // Interface Card Container
6207 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6208 // Placing Volumes in Mother Supply Card Container
6209 // JMD Connector Positioning
6210 TGeoTranslation* jmdconnectortrans[2];
6211 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6212 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6213 fgkEndCapCardElectBoardBackLength[0]
6214 - fgkEndCapCardJMDConnectorThickness
6215 - fgkEndCapCardJMDConnectorToLayer);
6216 TGeoRotation* jmdconnectorot = new TGeoRotation();
6217 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6218 + 2.*fgkEndCapCardJMDConnectorLength[0]
6219 + 2.*fgkEndCapCardElectBoardLayerThickness,
6220 fgkEndCapCardElectBoardLayerWidth[1],
6221 fgkEndCapCardJMDConnectorThickness
6222 + fgkEndCapCardJMDConnectorToLayer);
6223 jmdconnectorot->SetAngles(90.,180.,-90);
6224 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6225 * jmdconnectorot);
6226 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6227 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6228 // Top Cable Connector Placing
6229 TGeoRotation* cableconnectorot[2];
6230 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6231 TGeoTranslation* cableconnectortrans[3];
6232 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6233 cableconnectorot[0]->SetAngles(90.,0.,0.);
6234 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6235 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6236 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6237 *cableconnectorot[0]);
6238 TGeoHMatrix* cableconnectormatrix[2];
6239 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6240 new TGeoHMatrix((*cableconnectorot[1])
6241 *(*cableconnectorcombitrans));
6242 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6243 - fgkEndCapCardCableConnectorThickness,
6244 fgkEndCapCardCableConnectorLength[0]
6245 + fgkEndCapCardCableConnectorToLayer);
6246 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6247 - 2.*fgkEndCapCardCableConnectorThickness
6248 - fgkEndCapCardCableConnectorDistance,
6249 fgkEndCapCardCableConnectorLength[0]
6250 + fgkEndCapCardCableConnectorToLayer);
6251 for(Int_t i=0; i<2; i++){
6252 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6253 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6254 }
6255 TGeoRotation* electboardbackrot = new TGeoRotation();
6256 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6257 electboardbackrot->SetAngles(90.,-90.,-90.);
6258 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6259 + fgkEndCapCardJMDConnectorLength[0]
6260 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6261 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6262 *electboardbackrot);
6263 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6264 // Electronic Board Kapton Layer Positioning
6265 TGeoRotation* electlayerrot = new TGeoRotation();
6266 TGeoTranslation* electlayertrans[2];
6267 TGeoCombiTrans* electlayercombitrans[2];
6268 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6269 electlayerrot->SetAngles(90.,-90.,-90.);
6270 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6271 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6272 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6273 + 2.*fgkEndCapCardElectBoardLayerThickness
6274 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6275 for(Int_t i=0; i<2; i++){
6276 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6277 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6278 }
6279 // Placing Volumes in Mother Interface Card Container
6280 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6281 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6282 for(Int_t i=0; i<2; i++){
6283 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6284 }
6285 /////////////////////////////////////////////////////////////
6286 // Generation of Card Interface Container
6287 /////////////////////////////////////////////////////////////
6288 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6289 - fgkEndCapCardJMDConnectorLength[0]
6290 - fgkEndCapInterfaceCardBThickness
6291 - 9.*fgkEndCapStripConnectionThickness
6292 - 8.*fgkEndCapCardElectBoardBackThickness;
6293 const Int_t kcardinterfacecontainervertexnumber = 14;
6294 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6295 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6296 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6297 - 7.0*fgkEndCapStripConnectionThickness;
6298 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6299 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6300 + fgkEndCapStripConnectionThickness
6301 - fgkEndCapCardElectBoardLayerThickness
6302 - fgkEndCapCardCableConnectorWidth[0];
6303 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6304 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6305 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6306 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6307 + 2.0*fgkEndCapStripConnectionThickness;
6308 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6309 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6310 + fgkEndCapInterfaceCardBThickness;
6311 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6312 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6313 + fgkEndCapInterfaceElectBoardCardBThickness;
6314 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6315 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6316 - fgkEndCapInterfaceElectBoardCardBThickness
6317 + fgkEndCapCardJMDConnectorLength[0]
6318 + stiffenertransx+fgkEndCapStiffenerWidth;
6319 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6320
6321 ycardinterfacecontainervertex[0] = 0.;
6322 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6323 + fgkEndCapCardJMDConnectorWidth[0]
6324 + fgkEndCapCardJMDConnectorWidth[1];
6325 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6326 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6327 - fgkEndCapStripConnectionWidth;
6328 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6329 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6330 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6331 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6332 + fgkEndCapInterfaceCardBWidth[1]
6333 + fgkEndCapInterfaceCardBWidth[2];
6334 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6335 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6336 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6337 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6338 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6339 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6340
6341 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6342 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6343 xcardinterfacecontainervertex,
6344 ycardinterfacecontainervertex);
6345 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6346 - fgkEndCapCardElectBoardBackLength[0]));
6347 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6348 + fgkEndCapCardElectBoardBackLength[0]));
6349 TGeoVolume** cardinterfacecontainer;
6350 cardinterfacecontainer = new TGeoVolume*[4];
6351 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6352 interfacecardmothershape,fSSDAir);
6353 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6354 interfacecardmothershape,fSSDAir);
6355 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6356 interfacecardmothershape,fSSDAir);
6357 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6358 interfacecardmothershape,fSSDAir);
6359 /////////////////////////////////
6360 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6361 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6362 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6363 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6364 /////////////////////////////////
6365 TGeoRotation* endcapstripconnectionrot[2];
6366 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6367 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6368 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6369 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6370 * (*endcapstripconnectionrot[0]));
6371 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6372 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6373 -0.5*fgkEndCapCardElectBoardBackThickness,
6374 fgkEndCapCardElectBoardBackWidth[0]
6375 -endcapstripconnectionshape->GetDZ(),
6376 0.5*fgkEndCapCardElectBoardBackLength[0]);
6377 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6378 TGeoTranslation* cardinterfacetrans[9];
6379 TGeoHMatrix* cardinterfacematrix[9];
6380 for(Int_t i=0; i<7; i++){
6381 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6382 + fgkEndCapCardElectBoardBackThickness),
6383 0.0,0.0);
6384 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6385 * (*endcapstripconnectionmatrix));
6386 }
6387 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6388 + fgkEndCapCardElectBoardBackThickness),
6389 0.0,0.0);
6390 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6391 * (*endcapstripconnectionmatrix));
6392 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6393 + fgkEndCapCardElectBoardBackThickness),
6394 0.0,0.0);
6395 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6396 * (*endcapstripconnectionmatrix));
6397
6398 for(Int_t i=0; i<4; i++){
6399 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6400 cardinterfacematrix[7]);
6401 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6402 cardinterfacematrix[8]);
6403 }
6404 TGeoTranslation* mothersupplycardtrans =
6405 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6406 + 2.*fgkEndCapCardJMDConnectorLength[0]
6407 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6408 TGeoHMatrix* mothersupplycardmatrix[7];
6409 Int_t index[4] = {1,1,1,1};
6410 for(Int_t i=0; i<7; i++){
6411 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6412 * (*mothersupplycardtrans));
6413 for(Int_t j=0; j<4; j++){
6414 switch(j){
6415 case 0: //Layer5 EndCap Left Side
6416 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6417 cardinterfacematrix[i]);
6418 if(i!=0){
6419 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6420 mothersupplycardmatrix[i]);
6421 index[j]++;
6422
6423 }
6424 break;
6425 case 1: //Layer5 EndCap Rigth Side
6426 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6427 cardinterfacematrix[i]);
6428 if(i>0&&i<6){
6429 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6430 mothersupplycardmatrix[i]);
6431 index[j]++;
6432 }
6433 break;
6434 case 2: //Layer6 EndCap Left Side
6435 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6436 cardinterfacematrix[i]);
6437 if(i!=6){
6438 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6439 mothersupplycardmatrix[i]);
6440 index[j]++;
6441 }
6442 break;
6443 case 3: //Layer6 EndCap Right Side
6444 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6445 cardinterfacematrix[i]);
6446 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6447 mothersupplycardmatrix[i]);
6448 index[j]++;
6449 break;
6450 }
6451 }
6452 }
6453 // Positioning Interface
6454 TGeoTranslation* motherinterfacecardtrans =
6455 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6456 +0.5*fgkEndCapCardElectBoardBackThickness
6457 -fgkEndCapCardElectBoardLayerThickness
6458 +fgkEndCapStripConnectionThickness,0.,0.);
6459 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6460 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6461 // Positioning Interface Card B
6462 TGeoTranslation* interfacecardBmothertrans =
6463 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6464 + 2.*fgkEndCapStripConnectionThickness
6465 + fgkEndCapCardElectBoardBackThickness,0.,
6466 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6467 - fgkEndCapCardElectBoardBackLength[0]));
6468 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6469 interfacecardBmothertrans);
6470 // Positioning Stiffener
6471 TGeoTranslation* endcapstiffenertrans =
6472 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6473 + 2.0*fgkEndCapStripConnectionThickness
6474 + fgkEndCapInterfaceCardBThickness
6475 + fgkEndCapCardJMDConnectorLength[0]
6476 + stiffenertransx
6477 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6478 endcapstiffenershape->GetDZ()
6479 - 0.5*(fgkEndCapStiffenerLength
6480 - fgkEndCapCardElectBoardBackLength[0]));
6481 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6482 /////////////////////////////////////////////////////////////
6483 // Deallocating memory
6484 /////////////////////////////////////////////////////////////
6485 delete interfacecardBrot;
6486 delete interfacecardBtrans;
6487 delete electboardcardBtrans;
6488 delete electboardcardBrot;
6489 delete jmdconnectorcardBrot;
6490 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6491 delete jmdconnectorot;
6492 delete jmdconnectortrans[1];
6493 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6494 delete cableconnectorcombitrans;
6495 delete electboardbacktrans;
6496 delete electboardbackrot;
6497 delete electlayerrot;
6498 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6499 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6500 delete mothersupplycardtrans;
6501 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6502 /////////////////////////////////////////////////////////////
6503 return cardinterfacecontainer;
6504 }
6505 ////////////////////////////////////////////////////////////////////////////////
6506 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6507 /////////////////////////////////////////////////////////////
6508 // Method returning EndCap Mother Volume
6509 /////////////////////////////////////////////////////////////
6510 const Int_t kendcapcoverplatesmallholenumber = 9;
6511 Double_t endcapmotherorigin[3];
6512 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6513 + 0.5 *(fgkEndCapCoverPlateLength[3]
6514 + 2.0 * fgkEndCapCoverPlateLength[2]);
6515 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6516 - fgkEndCapCoverPlateWidth[2]
6517 - (kendcapcoverplatesmallholenumber-1)
6518 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6519 + 0.5*(fgkEndCapSideCoverLength[2]
6520 + fgkEndCapCoverPlateWidth[1]
6521 - fgkEndCapCoverPlateWidth[0])
6522 - (fgkEndCapCoverPlateWidth[1]
6523 - fgkEndCapCoverPlateWidth[0]);
6524 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6525 + 2.*fgkEndCapCoolingTubeRadiusMax
6526 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6527 + fgkEndCapSideCoverWidth[1]
6528 + fgkEndCapSideCoverThickness
6529 + fgkEndCapKaptonFoilThickness);
6530 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6531 + 2.0* fgkEndCapCoverPlateLength[2]
6532 + 2.0* fgkEndCapSideCoverThickness),
6533 0.5* (fgkEndCapSideCoverLength[2]
6534 + fgkEndCapCoverPlateWidth[1]
6535 - fgkEndCapCoverPlateWidth[0]),
6536 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6537 + fgkEndCapSideCoverWidth[1]
6538 + fgkEndCapSideCoverThickness
6539 + fgkEndCapKaptonFoilThickness),
6540 endcapmotherorigin);
6541 TGeoVolume** endcapassembly;
6542 endcapassembly = new TGeoVolume*[4];
6543 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6544 endcapmothershape,fSSDAir);
6545 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6546 endcapmothershape,fSSDAir);
6547 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6548 endcapmothershape,fSSDAir);
6549 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6550 endcapmothershape,fSSDAir);
6551 /////////////////////////////////
6552 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6553 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6554 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6555 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6556 /////////////////////////////////
6557 /////////////////////////////////////////////////////
6558 // Placing Endcap Cover Plate
6559 /////////////////////////////////////////////////////
6560 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6561 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6562 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6563 TGeoCombiTrans* endcapcoverplatecombitrans =
6564 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6565 endcapcoverplaterot);
6566 TGeoTranslation* endcapcoverplatetrans =
6567 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6568 TGeoHMatrix* endcapcoverplatematrix =
6569 new TGeoHMatrix((*endcapcoverplatetrans)
6570 * (*endcapcoverplatecombitrans));
6571 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6572 /////////////////////////////////////////////////////
6573 // Placing Endcap Side Cover
6574 /////////////////////////////////////////////////////
6575 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6576 TGeoRotation* endcapsidecoverot[2];
6577 TGeoCombiTrans* endcapsidecovercombitrans[3];
6578 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6579 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6580 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6581 - 0.5*(fgkEndCapCoverPlateWidth[0]
6582 - fgkEndCapCoverPlateWidth[2]
6583 - (kendcapcoverplatesmallholenumber-1)
6584 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6585 + 0.*fgkEndCapCoverPlateWidth[0]
6586 + fgkEndCapSideCoverLength[2],
6587 0.5*(fgkEndCapSideCoverThickness
6588 + fgkEndCapCoverPlateThickness)
6589 - 0.5*fgkEndCapCoverPlateThickness,
6590 endcapsidecoverot[0]);
6591 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6592 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6593 0.5*fgkEndCapCoverPlateThickness
6594 -fgkEndCapSideCoverWidth[1],
6595 endcapsidecoverot[1]);
6596 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6597 +fgkEndCapCoverPlateLength[3]
6598 +2.*fgkEndCapCoverPlateLength[2]
6599 +fgkEndCapSideCoverThickness,0.0,
6600 0.5*fgkEndCapCoverPlateThickness
6601 -fgkEndCapSideCoverWidth[1],
6602 endcapsidecoverot[1]);
6603 TGeoHMatrix* endcapsidecovermatrix[2];
6604 for(Int_t i=0; i<2; i++){
6605 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6606 * (*endcapsidecovercombitrans[0]));
6607 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6608 endcapsidecovermatrix[i]);
6609 }
6610 /////////////////////////////////////////////////////
6611 // Placing Endcap Cooling Tube
6612 /////////////////////////////////////////////////////
6613 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6614 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6615 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6616 TGeoCombiTrans* endcapccolingtubecombitrans
6617 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6618 + fgkEndCapCoolingTubeAxialRadius[1])
6619 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6620 - fgkEndCapCoolingTubeToCoverSide,
6621 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6622 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6623 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6624 endcapccolingtubecombitrans);
6625 /////////////////////////////////////////////////////
6626 // Placing Screws
6627 /////////////////////////////////////////////////////
6628 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6629 fgkEndCapCoverPlateScrewRadiusMin};
6630 Int_t screwcoverplatedgesnumber[2] = {20,20};
6631 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6632 fgkEndCapCoverPlateThickness
6633 + fgkEndCapCoolingTubeRadiusMax};
6634 TGeoXtru* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
6635 screwcoverplatedgesnumber,
6636 screwcoverplatesection);
6637 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6638 screwcoverplateshape,
6639 fSSDCoolingTubePhynox);
6640 screwcoverplate->SetLineColor(12);
6641 Double_t transx[4] = {0,
6642 fgkEndCapCoverPlateSmallHoleSeparation[0],
6643 fgkEndCapCoverPlateSmallHoleSeparation[0]
6644 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6645 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6646 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6647 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6648// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6649 TGeoTranslation*** endcapcoverplatescrewtrans;
6650 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6651 Int_t index = 0;
6652 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6653 endcapcoverplatescrewtrans[i] =
6654 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6655 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6656 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6657 if(index==1||index==9||index==28||index==36){
6658 endcapcoverplatescrewtrans[i][j] =
6659 new TGeoTranslation(transx[i],
6660 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6661 fgkEndCapSideCoverThickness);
6662 }
6663 else{
6664 endcapcoverplatescrewtrans[i][j] =
6665 new TGeoTranslation(transx[i],
6666 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6667 0.);
6668 }
6669 if(index!=19)
6670 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6671 endcapcoverplatescrewtrans[i][j]);
6672 }
6673 }
6674 /////////////////////////////////////////////////////
6675 // Placing Cover Plate Clips
6676 /////////////////////////////////////////////////////
6677 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6678 0.5*fgkEndCapCoverPlateClipWidth,
6679 0.5*fgkEndCapSideCoverThickness);
6680 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6681 endcapcoverplateclipshape,
6682 fSSDCoolingTubePhynox);
6683 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6684 0.5*fgkEndCapCoverPlateDownClipWidth,
6685 0.5*fgkEndCapSideCoverThickness);
6686 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6687 endcapcoverplatedownclipshape,
6688 fSSDCoolingTubePhynox);
6689 TGeoTranslation* endcapcoverplatecliptrans[4];
6690 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6691 - fgkEndCapCoverPlateLength[0]
6692 - fgkEndCapSideCoverThickness,
6693 0.0,
6694 0.5*(fgkEndCapSideCoverThickness
6695 + fgkEndCapCoverPlateThickness));
6696 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6697 - fgkEndCapCoverPlateLength[0]
6698 - fgkEndCapSideCoverThickness,
6699 (kendcapcoverplatescrewnumber[1]-1)
6700 * fgkEndCapSideCoverWidth[5],
6701 0.5*(fgkEndCapSideCoverThickness
6702 + fgkEndCapCoverPlateThickness));
6703 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6704 - fgkEndCapCoverPlateLength[0]
6705 + fgkEndCapCoverPlateLength[1]
6706 + 2.*fgkEndCapCoverPlateLength[0]
6707 - fgkEndCapCoverPlateClipLength
6708 + fgkEndCapSideCoverThickness,
6709 0.0,
6710 0.5*(fgkEndCapSideCoverThickness
6711 + fgkEndCapCoverPlateThickness));
6712 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6713 - fgkEndCapCoverPlateLength[0]
6714 + fgkEndCapCoverPlateLength[1]
6715 + 2.*fgkEndCapCoverPlateLength[0]
6716 - fgkEndCapCoverPlateClipLength
6717 + fgkEndCapSideCoverThickness,
6718 (kendcapcoverplatescrewnumber[1]-1)
6719 * fgkEndCapSideCoverWidth[5],
6720 0.5*(fgkEndCapSideCoverThickness
6721 + fgkEndCapCoverPlateThickness));
6722 endcapcoverplateclip->SetLineColor(fColorPhynox);
6723 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6724 for(Int_t i=0; i<4; i++)
6725 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6726 endcapcoverplatecliptrans[i]);
6727 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6728 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6729 - fgkEndCapCoverPlateLength[0]
6730 - fgkEndCapSideCoverThickness,
6731 0.5*(fgkEndCapCoverPlateDownClipWidth
6732 - fgkEndCapCoverPlateClipWidth),
6733 0.5*(fgkEndCapSideCoverThickness
6734 + fgkEndCapCoverPlateThickness)
6735 - fgkEndCapSideCoverWidth[1]
6736 - fgkEndCapSideCoverThickness);
6737 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6738 - fgkEndCapCoverPlateLength[0]
6739 - fgkEndCapSideCoverThickness,
6740 0.5*(fgkEndCapCoverPlateDownClipWidth
6741 - fgkEndCapCoverPlateClipWidth)
6742 + fgkEndCapSideCoverLength[2]
6743 - fgkEndCapCoverPlateDownClipWidth,
6744 0.5*(fgkEndCapSideCoverThickness
6745 + fgkEndCapCoverPlateThickness)
6746 - fgkEndCapSideCoverWidth[1]
6747 - fgkEndCapSideCoverThickness);
6748 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6749 - fgkEndCapCoverPlateLength[0]
6750 + fgkEndCapSideCoverThickness
6751 + fgkEndCapCoverPlateLength[1]
6752 + 2.0*fgkEndCapCoverPlateLength[0]
6753 - fgkEndCapCoverPlateDownClipLength,
6754 0.5*(fgkEndCapCoverPlateDownClipWidth
6755 - fgkEndCapCoverPlateClipWidth),
6756 0.5*(fgkEndCapSideCoverThickness
6757 + fgkEndCapCoverPlateThickness)
6758 - fgkEndCapSideCoverWidth[1]
6759 - fgkEndCapSideCoverThickness);
6760 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6761 - fgkEndCapCoverPlateLength[0]
6762 + fgkEndCapSideCoverThickness
6763 + fgkEndCapCoverPlateLength[1]
6764 + 2.0*fgkEndCapCoverPlateLength[0]
6765 - fgkEndCapCoverPlateDownClipLength,
6766 0.5*(fgkEndCapCoverPlateDownClipWidth
6767 - fgkEndCapCoverPlateClipWidth)
6768 + fgkEndCapSideCoverLength[2]
6769 - fgkEndCapCoverPlateDownClipWidth,
6770 0.5*(fgkEndCapSideCoverThickness
6771 + fgkEndCapCoverPlateThickness)
6772 - fgkEndCapSideCoverWidth[1]
6773 - fgkEndCapSideCoverThickness);
6774 for(Int_t i=0; i<4; i++)
6775 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6776 endcapcoverplatedowncliptrans[i]);
6777 /////////////////////////////////////////////////////
6778 // Placing Kapton Foil
6779 /////////////////////////////////////////////////////
6780 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6781 0.5*fgkEndCapKaptonFoilWidth,
6782 0.5*fgkEndCapKaptonFoilThickness);
6783 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6784 endcapkaptonfoilshape,
6785 fSSDKaptonFlexMedium);
6786 endcapkaptonfoil->SetLineColor(8);
6787 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6788 0.5*fgkEndCapKaptonFoilWidth
6789 - 0.5*fgkEndCapCoverPlateClipWidth,
6790 0.5*fgkEndCapCoverPlateThickness
6791 - 0.5*fgkEndCapKaptonFoilThickness
6792 - fgkEndCapSideCoverWidth[1]
6793 - fgkEndCapSideCoverThickness);
6794 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6795 /////////////////////////////////////////////////////////////
6796 // Placing Electronic Tubes
6797 /////////////////////////////////////////////////////////////
6798 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6799 - fgkEndCapInterfaceCardBThickness
6800 - 9.*fgkEndCapStripConnectionThickness
6801 - 8.*fgkEndCapCardElectBoardBackThickness,
6802 fgkEndCapKaptonFoilWidth
6803 - fgkEndCapInterfaceCardBThickness
6804 - 9.*fgkEndCapStripConnectionThickness
6805 - 8.*fgkEndCapCardElectBoardBackThickness
6806 - fgkEndCapInterfaceElectBoardCardBThickness};
6807 TGeoVolume* endcapeffectivecables[2];
6808 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6809 fgkEndCapEffectiveCableRadiusMax,
6810 endcapeffectivecableswidth[0],
6811 10,"EndCapEffectiveCables1");
6812 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6813 fgkEndCapEffectiveCableRadiusMax,
6814 endcapeffectivecableswidth[1],
6815 25,"EndCapEffectiveCables2");
6816 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6817 TGeoTranslation* endcapeffectivecablestrans[2];
6818 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6819 - 0.5*endcapeffectivecableswidth[0]
6820 - 0.5*(fgkEndCapCoverPlateWidth[0]
6821 - fgkEndCapCoverPlateWidth[2]
6822 - (kendcapcoverplatesmallholenumber-1)
6823 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6824 + fgkEndCapSideCoverLength[2],
6825 - 0.5*fgkEndCapCoverPlateThickness
6826 - (fgkEndCapCardElectBoardBackWidth[0]
6827 - fgkEndCapInterfaceCardBWidth[0]
6828 - fgkEndCapInterfaceCardBWidth[1]));
6829 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6830 - 0.5*endcapeffectivecableswidth[1]
6831 - 0.5*(fgkEndCapCoverPlateWidth[0]
6832 - fgkEndCapCoverPlateWidth[2]
6833 - (kendcapcoverplatesmallholenumber-1)
6834 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6835 + fgkEndCapSideCoverLength[2],
6836 - 0.5*fgkEndCapCoverPlateThickness
6837 - (fgkEndCapCardElectBoardBackWidth[0]
6838 - fgkEndCapInterfaceCardBWidth[0])
6839 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6840 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6841 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6842 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6843 *endcapeffectivecablesrot);
6844 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6845 *endcapeffectivecablesrot);
47f8de53 6846// for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6847// endcapeffectivecablescombitrans[0]);
9b0c60ab 6848 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6849 endcapeffectivecablescombitrans[1]);
6850 /////////////////////////////////////////////////////////////
6851 // Placing End Cap Cards
6852 /////////////////////////////////////////////////////////////
6853 TGeoVolume** endcapcards = GetEndCapCards();
6854 TGeoRotation* endcapcardsrot[2];
6855 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6856 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6857 TGeoTranslation* endcapcardstrans[2];
6858 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6859 - fgkEndCapCardElectBoardBackLength[0]));
6860 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6861 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6862 TGeoHMatrix* endcapcardsmatrix[2];
6863 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6864 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6865 - fgkEndCapCardJMDConnectorLength[0]
6866 - fgkEndCapInterfaceCardBThickness
6867 - 9.*fgkEndCapStripConnectionThickness
6868 - 8.*fgkEndCapCardElectBoardBackThickness;
6869 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6870 - fgkEndCapCoverPlateLength[0]
6871 + 0.5 * (fgkEndCapCoverPlateLength[3]
6872 + 2.0 * fgkEndCapCoverPlateLength[2]),
6873 - stiffenertransx-fgkEndCapStiffenerWidth
6874 - fgkEndCapCardJMDConnectorLength[0]
6875 - fgkEndCapInterfaceCardBThickness
6876 - 2.0 * fgkEndCapStripConnectionThickness
6877 - 1.5 * fgkEndCapInterfaceCardBThickness
6878 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6879 - fgkEndCapCoverPlateWidth[2]
6880 - (kendcapcoverplatesmallholenumber-1)
6881 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6882 + fgkEndCapKaptonFoilWidth,
6883 0.5*fgkEndCapCoverPlateThickness
6884 - fgkEndCapSideCoverWidth[1]);
6885 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6886 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6887 /////////////////////////////////////////////////////////////
6888 // Deallocating memory
6889 /////////////////////////////////////////////////////////////
6890 delete endcapcoverplaterot;
6891 delete endcapcoverplatecombitrans;
6892 delete endcapcoverplatetrans;
6893 for(Int_t i=0; i<3; i++){
6894 delete endcapsidecovercombitrans[i];
6895 if(i<2) delete endcapsidecoverot[i];
6896 }
6897 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6898 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6899 delete endcapcardsmatrix[0];
6900 return endcapassembly;
6901 }
6902 ////////////////////////////////////////////////////////////////////////////////
6903 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6904 Double_t radiusmax,
6905 Double_t width,
6906 Int_t ncables,
6907 char* volname){
6908 /////////////////////////////////////////////////////////////
6909 // Generating EndCap High Voltage Tubes
6910 /////////////////////////////////////////////////////////////
6911 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
6912 Double_t effectiveouteradius = TMath::Sqrt(TMath::Power(effectiveinneradius,2.)
6913 + TMath::Power(radiusmax,2.)
6914 - TMath::Power(radiusmin,2.));
6915 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6916 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6917 effectiveouteradius,0.5*width);
6918 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6919 effectiveinnertubeshape,
6920 fSSDStiffenerConnectorMedium);
6921 effectiveinnertube->SetLineColor(41);
6922 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6923 effectiveoutertubeshape,
6924 fSSDKaptonChipCableMedium);
6925 effectiveoutertube->SetLineColor(39);
6926 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6927 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6928 effectivemothertube->AddNode(effectiveinnertube,1);
6929 effectivemothertube->AddNode(effectiveoutertube,1);
6930 return effectivemothertube;
6931 }
6932 ////////////////////////////////////////////////////////////////////////////////
6933 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6934 /////////////////////////////////////////////////////////////
6935 // Generating EndCap Support Layer 5 and Layer 6
6936 /////////////////////////////////////////////////////////////
6937 const Int_t knedges = 5;
6938 ///////////////////////////////////////////////
6939 // Setting the vertices for TGeoXtru Up Volume
6940 ///////////////////////////////////////////////
6941 const Int_t klayernumber = 2;
6942 Double_t xupvertex[klayernumber][knedges+3];
6943 Double_t yupvertex[klayernumber][knedges+3];
6944 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6945 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6946 Double_t middlepsi[klayernumber] = {0.0,0.0};
6947 for(Int_t i=0; i<klayernumber; i++){
6948 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6949 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6950 xupvertex[i][2] = -xupvertex[i][1];
6951 xupvertex[i][3] = -xupvertex[i][0];
6952
6953 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6954 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6955 yupvertex[i][2] = yupvertex[i][1];
6956 yupvertex[i][3] = yupvertex[i][0];
6957
6958 middledgeangle[i] = upedgeangle[i]/knedges;
6959 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6960 for(Int_t j=1; j<knedges; j++){
6961 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6962 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6963 }
6964 }
6965 ////////////////////////////////////
6966 // Generating Up TGeoXtru
6967 ////////////////////////////////////
6968 TGeoXtru* upendcapsupportshape[klayernumber];
6969 TGeoVolume* upendcapsupport[klayernumber];
6970 char upendcapsupportname[30];
6971 for(Int_t i=0; i<klayernumber; i++){
6972 upendcapsupportshape[i] = new TGeoXtru(2);
6973 sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6974 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6975 upendcapsupportshape[i]->DefineSection(0,0.);
6976 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6977 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 6978 fSSDSupportRingAl);
9b0c60ab 6979 upendcapsupport[i]->SetLineColor(5);
6980 }
6981 ///////////////////////////////////////////////
6982 // Setting the vertices for TGeoXtru Down Volume
6983 ///////////////////////////////////////////////
6984 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6985 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6986 for(Int_t i=0; i<klayernumber; i++){
6987 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6988 xdownvertex[i][1] = xupvertex[i][0];
6989 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6990 ydownvertex[i][1] = yupvertex[i][0];
6991 for(Int_t j=0; j<knedges; j++){
6992 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6993 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6994 }
6995 for(Int_t j=0; j<knedges; j++){
6996 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6997 * CosD(middlepsi[i]+j*middledgeangle[i]);
6998 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6999 * SinD(middlepsi[i]+j*middledgeangle[i]);
7000 }
7001 }
7002 ////////////////////////////////////
7003 // Generating Down TGeoXtru
7004 ////////////////////////////////////
7005 TGeoXtru* downendcapsupportshape[klayernumber];
7006 TGeoVolume* downendcapsupport[klayernumber];
7007 char downendcapsupportname[30];
7008 for(Int_t i=0; i<klayernumber; i++){
7009 downendcapsupportshape[i] = new TGeoXtru(2);
7010 sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
7011 downendcapsupportshape[i] = new TGeoXtru(2);
7012 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
7013 if(i==0){
7014 downendcapsupportshape[i]->DefineSection(0,0.);
7015 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
7016 }
7017 else{
7018 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
7019 - fgkEndCapSupportLowWidth[i]);
7020 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
7021 }
7022 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 7023 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 7024 downendcapsupport[i]->SetLineColor(5);
7025 }
7026 ///////////////////////////////////////////////
7027 // Setting TGeoPgon Volume
7028 ///////////////////////////////////////////////
7029 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
7030 fgkSSDLay6LadderNumber};
7031 TGeoPgon* endcapsupportmothershape[klayernumber];
7032 TGeoVolume** endcapsupportmother;
7033 endcapsupportmother = new TGeoVolume*[klayernumber];
7034 char endcapsupportmothername[30];
7035 for(Int_t i=0; i<klayernumber; i++){
7036 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7037 sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
7038 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
7039 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
7040 ydownvertex[i][0],yupvertex[i][1]);
7041 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 7042 fSSDAir);
9b0c60ab 7043 }
7044 ////////////////////////////////////
7045 TGeoRotation** endcapsupportrot[klayernumber];
7046 for(Int_t i=0; i<2; i++){
7047 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
7048 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7049 endcapsupportrot[i][j] = new TGeoRotation();
7050 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
7051 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
7052 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
7053 }
7054 }
7055 return endcapsupportmother;
7056 }
7057 ////////////////////////////////////////////////////////////////////////////////
7058 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
7059 /////////////////////////////////////////////////////////////
7060 // Setting End Cap Support Layer 5 and 6.
7061 /////////////////////////////////////////////////////////////
7062 const Int_t kendcapcoverplatesmallholenumber = 9;
7063 const Int_t klayernumber = 2;
7064 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
7065 fgkSSDLay6LadderNumber};
7066 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
7067 360.0/kssdlayladdernumber[1]};
7068 TGeoVolume** endcapsupport = EndCapSupport();
7069 TGeoVolume** endcapassembly = GetEndCapAssembly();
7070 TGeoPgon* endcapsupportshape[klayernumber];
7071 Double_t* radiusmin[klayernumber];
7072 Double_t* radiusmax[klayernumber];
7073 for(Int_t i=0; i<klayernumber; i++){
7074 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
7075 radiusmin[i] = endcapsupportshape[i]->GetRmin();
7076 radiusmax[i] = endcapsupportshape[i]->GetRmax();
7077 }
7078 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
7079 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
7080 endcapassemblyshape->GetDY(),
7081 endcapassemblyshape->GetDZ()};
7082 ///////////////////////////////////////////////
7083 // Setting TGeoPgon Volume for Mother Container
7084 ///////////////////////////////////////////////
7085 TGeoPgon* endcapsupportsystemshape[klayernumber];
7086 char endcapsupportsystemothername[30];
7087 for(Int_t i=0; i<klayernumber; i++){
7088 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
7089 sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
7090 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
7091 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
7092 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7093 +2.*endcapassemblycenter[2])
7094 /CosD(0.5*upedgeangle[i]));
7095 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7096 -(fgkEndCapCoverPlateWidth[1]
7097 - fgkEndCapCoverPlateWidth[0]),
7098 *radiusmin[i],
7099 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7100 +2.*endcapassemblycenter[2])
7101 /CosD(0.5*upedgeangle[i]));
7102 }
e5bf64ae 7103 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 7104 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7105 endcapsupportsystemshape[0],fSSDAir);
7106 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7107 endcapsupportsystemshape[0],fSSDAir);
7108 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7109 endcapsupportsystemshape[1],fSSDAir);
7110 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7111 endcapsupportsystemshape[1],fSSDAir);
7112 ///////////////////////////////////////////////
7113 TGeoTranslation* endcapassemblytrans[klayernumber];
7114 for(Int_t i=0; i<klayernumber; i++)
7115 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7116 - fgkEndCapSideCoverThickness
7117 + endcapassemblycenter[0],
7118 - 0.5*fgkEndCapCoverPlateThickness
7119 - 2.0*fgkEndCapCoolingTubeRadiusMax
7120 + 2.0*endcapassemblycenter[2]
7121 + 0.5*fgkEndCapSupportLength[i]
7122 / TanD(0.5*upedgeangle[i]),
7123 0.5*(fgkEndCapCoverPlateWidth[0]
7124 - fgkEndCapCoverPlateWidth[2]
7125 - (kendcapcoverplatesmallholenumber-1)
7126 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
7127 TGeoRotation** endcapassemblyrot[klayernumber];
7128 TGeoHMatrix** endcapassemblymatrix[klayernumber];
7129 for(Int_t i=0; i<klayernumber; i++){
7130 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7131 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7132 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7133 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7134 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7135 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7136 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7137 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7138 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7139 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7140 }
7141 }
7142 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7143 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7144 for(Int_t i=0; i<2*klayernumber; i++){
7145 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7146 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7147 endcapassemblymatrix[1][j+2]);
7148 }
7149 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7150 }
7151 /////////////////////////////////////////////////////////////
7152 // Deallocating memory
7153 /////////////////////////////////////////////////////////////
7154 for(Int_t i=0; i<klayernumber; i++){
7155 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7156 delete endcapassemblyrot[i][j];
7157 }
7158 delete endcapassemblyrot[i];
7159 delete endcapassemblymatrix[i][0];
7160 delete endcapassemblymatrix[i][1];
7161 }
7162 /////////////////////////////////////////////////////////////
7163 }
7164 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7165 /////////////////////////////////////////////////////////////
7166 // Setting End Cap Support + End Cap Assembly of Layer 5.
7167 /////////////////////////////////////////////////////////////
7168 if (! moth) {
7169 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer5, 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 fgkEndCapSupportCenterLay5ITSPosition
7176 + fgkEndCapSupportCenterLay5Position
7177 - fgkEndCapSideCoverLength[2]);
7178 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7179 fgkEndCapSideCoverLength[2]
7180 - fgkEndCapSupportCenterLay5Position
7181 - fgkEndCapSupportCenterLay5ITSPosition);
7182 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7183 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7184 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7185 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7186 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7187 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7188 /////////////////////////////////////////////////////////////
7189 // Deallocating memory
7190 /////////////////////////////////////////////////////////////
7191 delete endcapsupportsystemrot;
7192 delete endcapsupportsystemITSCentertrans[1];
7193 }
7194 /////////////////////////////////////////////////////////////
7195 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7196 /////////////////////////////////////////////////////////////
7197 // Setting End Cap Support + End Cap Assembly of Layer 6.
7198 /////////////////////////////////////////////////////////////
7199 if (! moth) {
7200 printf("Error::AliITSv11GeometrySSD: Can't insert end cap support of layer6, mother is null!\n");
7201 return;
7202 };
e5bf64ae 7203 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7204 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7205 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7206 fgkEndCapSupportCenterLay6ITSPosition
7207 + fgkEndCapSupportCenterLay6Position
7208 - fgkEndCapSideCoverLength[2]);
7209 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7210 fgkEndCapSideCoverLength[2]
7211 - fgkEndCapSupportCenterLay6Position
7212 - fgkEndCapSupportCenterLay6ITSPosition);
7213 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7214 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7215 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7216 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7217 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7218 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7219 /////////////////////////////////////////////////////////////
7220 // Deallocating memory
7221 /////////////////////////////////////////////////////////////
7222 delete endcapsupportsystemrot;
7223 delete endcapsupportsystemITSCentertrans[1];
7224 }
7225 ////////////////////////////////////////////////////////////////////////////////
7226 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7227 /////////////////////////////////////////////////////////////
7228 // Setting Ladder Support of Layer 5.
7229 /////////////////////////////////////////////////////////////
7230 if (! moth) {
7231 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer5, mother is null!\n");
7232 return;
7233 };
7234 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7235 fMotherVol = moth;
7236 TGeoTranslation* centerITSRingSupportLay5trans[2];
7237 for(Int_t i=0; i<2; i++){
7238 centerITSRingSupportLay5trans[i] =
7239 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7240 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7241 }
7242 }
7243 ////////////////////////////////////////////////////////////////////////////////
7244 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7245 /////////////////////////////////////////////////////////////
7246 // Setting Ladder Support of Layer 6.
7247 /////////////////////////////////////////////////////////////
7248 if (! moth) {
7249 printf("Error::AliITSv11GeometrySSD: Can't insert ladder lupport of layer6, mother is null!\n");
7250 return;
7251 };
7252 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7253 fMotherVol = moth;
7254 TGeoTranslation* centerITSRingSupportLay6trans[2];
7255 for(Int_t i=0; i<2; i++){
7256 centerITSRingSupportLay6trans[i] =
7257 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7258 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7259 }
7260 }
7261 ////////////////////////////////////////////////////////////////////////////////
47f8de53 7262 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7263 /////////////////////////////////////////////////////////////
7264 // Setting Ladder Support of Layer 6.
7265 /////////////////////////////////////////////////////////////
7266 if (! moth) {
7267 printf("Error::AliITSv11GeometrySSD: Can't insert SSD Cone, mother is null!\n");
7268 return;
7269 };
7270 if(!fSSDCone) SetSSDCone();
7271 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7272 + fgkSSDCentralAL3SupportLength);
7273 moth->AddNode(fSSDCone,1,ssdconetrans);
7274}
7275 ////////////////////////////////////////////////////////////////////////////////
7276 void AliITSv11GeometrySSD::SetSSDCone(){
7277 /////////////////////////////////////////////////////////////
7278 // Method generating SSDCone
7279 /////////////////////////////////////////////////////////////
7280 if(!fCreateMaterials) CreateMaterials();
7281 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7282 Double_t ssdpconesectionradiusmax[16];
7283 Double_t ssdpconesectionradiusmin[16];
7284 Double_t ssdpconezsection[16];
7285 TGeoPcon* ssdpconelittleholeshape[8];
7286 TGeoVolume* ssdpconelittlehole[8];
7287 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7288 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7289 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7290 / SinD(fgkSSDPConeAngle)
7291 + ssdpconesectionradiusmin[0];
7292 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7293 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7294 / SinD(fgkSSDPConeAngle);
7295 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7296 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7297 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7298 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7299 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7300 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7301 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7302 ssdpconelittlehole[0]->SetLineColor(4);
7303 /////////////////////////////////////////////////////////////
7304 ssdpconezsection[2] = ssdpconezsection[1];
7305 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7306 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7307 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7308 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7309 / SinD(fgkSSDPConeAngle);
7310 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7311 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7312 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7313 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7314 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7315 * TMath::RadToDeg();
7316 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7317 60.-ssdpconelittleholeangle,2);
7318 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7319 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7320 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7321 ssdpconelittlehole[1]->SetLineColor(4);
7322 TGeoRotation* ssdconelittleholerot[6];
7323 for(Int_t i=0; i<6; i++){
7324 ssdconelittleholerot[i] = new TGeoRotation();
7325 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7326 }
7327 /////////////////////////////////////////////////////////////
7328 ssdpconezsection[4] = ssdpconezsection[3];
7329 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7330 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7331 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7332 * CosD(fgkSSDPConeAngle)
7333 / SinD(fgkSSDPConeAngle);
7334 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7335 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7336 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7337 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7338 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7339 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7340 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7341 ssdpconelittlehole[2]->SetLineColor(4);
7342 ///////////////////////////////////////////////////
7343 ssdpconezsection[6] = ssdpconezsection[5];
7344 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7345 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7346 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7347 -ssdpconezsection[0]
7348 * CosD(fgkSSDPConeAngle)
7349 / SinD(fgkSSDPConeAngle);
7350 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7351 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7352 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7353 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7354 * TMath::RadToDeg();
7355 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7356 45.-ssdpconemiddleholeangle,2);
7357 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7358 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7359 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7360 ssdpconelittlehole[3]->SetLineColor(4);
7361 TGeoRotation* ssdconemiddleholerot[8];
7362 for(Int_t i=0; i<8; i++){
7363 ssdconemiddleholerot[i] = new TGeoRotation();
7364 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7365 }
7366 /////////////////////////////////////////////////////////////
7367 ssdpconezsection[8] = ssdpconezsection[7];
7368 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7369 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7370 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7371 * CosD(fgkSSDPConeAngle)
7372 / SinD(fgkSSDPConeAngle);
7373 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7374 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7375 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7376 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7377 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7378 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7379 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7380 ssdpconelittlehole[4]->SetLineColor(4);
7381 /////////////////////////////////////////////////////////////
7382 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7383 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7384 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7385 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7386 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7387 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7388 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7389 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7390 * TMath::RadToDeg();
7391 ssdpconezsection[10] = ssdpconezsection[9];
7392 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7393 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7394 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7395 * CosD(fgkSSDPConeAngle)
7396 / SinD(fgkSSDPConeAngle);
7397 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7398 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7399 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7400 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7401 ssdpconetrapezoidsectionangle,2);
7402 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7403 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7404 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7405 ssdpconelittlehole[5]->SetLineColor(4);
7406 TGeoRotation* ssdconeupradiusrot[8];
7407 for(Int_t i=0; i<8; i++){
7408 ssdconeupradiusrot[i] = new TGeoRotation();
7409 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7410 }
7411 /////////////////////////////////////////////////////////////
7412 ssdpconezsection[12] = ssdpconezsection[11];
7413 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7414 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7415 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7416 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7417 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7418 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7419 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7420 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7421 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7422 ssdpconelittlehole[6]->SetLineColor(4);
7423 /////////////////////////////////////////////////////////////
7424 ssdpconezsection[14] = 0.0;
7425 ssdpconezsection[15] = ssdpconezsection[0];
7426 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7427 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7428 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7429 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7430 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7431 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7432 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7433 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7434 ssdpconelittlehole[7]->SetLineColor(4);
7435 /////////////////////////////////////////////////////////////
7436 TGeoTube* ssdtubeconeshape[2];
7437 TGeoVolume* ssdtubecone[2];
7438 TGeoTranslation* ssdtubeconetrans[2];
7439 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7440 fgkSSDPConeExternalRadius,
7441 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7442 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7443 0.5*ssdpconezsection[0]);
7444 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7445 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7446 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7447 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7448 + ssdpconezsection[13]);
7449 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7450 ssdtubecone[0]->SetLineColor(4);
7451 ssdtubecone[1]->SetLineColor(4);
7452 /////////////////////////////////////////////////////////////
7453 // Mother Volume Container
7454 /////////////////////////////////////////////////////////////
7455 Double_t ssdconemotherradiusmin[8];
7456 Double_t ssdconemotherradiusmax[8];
7457 Double_t ssdconemothersection[8];
7458 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7459 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7460 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7461 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7462 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7463 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7464 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7465 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7466 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7467 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7468 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7469 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7470 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7471 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7472 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7473 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7474 ssdconemothersection[0] = 0.0;
7475 ssdconemothersection[1] = ssdpconezsection[0];
7476 ssdconemothersection[2] = ssdpconezsection[0];
7477 ssdconemothersection[3] = ssdpconezsection[11];
7478 ssdconemothersection[4] = ssdpconezsection[11];
7479 ssdconemothersection[5] = ssdpconezsection[13];
7480 ssdconemothersection[6] = ssdpconezsection[13];
7481 ssdconemothersection[7] = fgkSSDPConeLength;
7482 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7483 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7484 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7485 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7486 /////////////////////////////////////////////////////////////
7487 //Placing the Volumes into Mother
7488 /////////////////////////////////////////////////////////////
7489 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7490 for(Int_t i=0; i<6; i++){
7491 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7492 }
7493 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7494 for(Int_t i=0; i<8; i++){
7495 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7496 }
7497 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7498 for(Int_t i=0; i<8; i++){
7499 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7500 }
7501 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7502 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7503 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7504 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7505 /////////////////////////////////////////////////////////////
7506 // ITS General Support
7507 /////////////////////////////////////////////////////////////
7508 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7509 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7510 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7511 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7512 - fgkSSDCentralAL3SupportLength);
7513 ssdcentralsupport->SetLineColor(4);
7514 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7515 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7516 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7517 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7518 TGeoTranslation* ssdcentralal3supportrans[3];
7519 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7520 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7521 - 1.25*fgkSSDCentralAL3SupportLength);
7522 ssdcentralal3support->SetLineColor(4);
7523 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7524 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7525 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7526 Double_t ssdpconcentralradiusmin[2];
7527 Double_t ssdpconcentralradiusmax[2];
7528 Double_t ssdpconcentralsection[2];
7529 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7530 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7531 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7532 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7533 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7534 ssdpconcentralsection[1] = 0.;
7535 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7536 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7537 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7538 ssdpconcentralal3->SetLineColor(4);
7539 fSSDCone->AddNode(ssdpconcentralal3,1);
7540 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7541 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7542 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7543 -2.*fgkSSDCentralAL3SupportLength);
7544 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7545 *ssdcentralal3supportrot);
7546 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7547 TGeoRotation* ssdconemotherot = new TGeoRotation();
7548 ssdconemotherot->SetAngles(90.,180.,-90.);
7549 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7550 -2.*fgkSSDCentralAL3SupportLength);
7551 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7552 fSSDCone->AddNode(ssdconemother,1);
7553 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7554 /////////////////////////////////////////////////////////////
7555 // Deallocating memory
7556 /////////////////////////////////////////////////////////////
7557 delete ssdcentralal3supportrot;
7558 delete ssdcentralal3supportrans[2];
7559 delete ssdconemotherot;
7560 delete ssdconemothertrans;
7561 /////////////////////////////////////////////////////////////
7562 }
fcfbdd23 7563 ////////////////////////////////////////////////////////////////////////////////
7564 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7565 /////////////////////////////////////////////////////////////
7566 // Setting SSD Cables
7567 /////////////////////////////////////////////////////////////
7568 if (! moth) {
7569 printf("Error::AliITSv11GeometrySSD: Can't insert SSD Cables, mother is null!\n");
7570 return;
7571 };
7572 TGeoVolume* ssdcables = SetSSDCables();
7573 moth->AddNode(ssdcables,1);
7574}
47f8de53 7575 ////////////////////////////////////////////////////////////////////////////////
7576 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7577 /////////////////////////////////////////////////////////////
7578 // Method generating SSDCables
7579 /////////////////////////////////////////////////////////////
7580 // SSD Layer 5 Cables
7581 //////////////////////////////////////////////////////////////////////////////////////////////////
7582 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7583 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
fcfbdd23 7584 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
47f8de53 7585 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7586 //////////////////////////////////////////////////////////////////////////////////////////////////
7587 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+fgkSSDCablesLay5TubeRadiusMin;
7588 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7589 - fgkSSDLowerPConeRadius)
7590 * TanD(fgkSSDPConeAngle);
7591 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7592 + fgkEndCapSupportCenterLay5Position
7593 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7594 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7595 - ssdcableslay5startconedistance;
7596 ssdcablelay5rightsidelength *= ssdcablesfactor;
7597 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+fgkSSDCablesLay5RightSideHeight;
7598 TGeoTube* ssdcablelay5rightubeshape = new TGeoTube(ssdcableslay5rigthsideradiusmin,
7599 ssdcableslay5rightsideradiusmax,
7600 0.5*ssdcablelay5rightsidelength);
7601 TGeoVolume* ssdcablelay5righttube = new TGeoVolume("SSDCableLay5RightSideTube",
7602 ssdcablelay5rightubeshape,
7603 fSSDCopper);
7604 ssdcablelay5righttube->SetLineColor(9);
7605 TGeoTranslation* ssdcablelay5rightrans =
7606 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7607 + fgkEndCapSupportCenterLay5Position
7608 + 0.5*ssdcablelay5rightsidelength);
7609 ////////////////////////////////////
7610 // Double_t cablescapacity[20];
7611 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7612 ////////////////////////////////////
7613 ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7614 ////////////////////////////////////
7615 // TGeoPCone Volumes
7616 ///////////////////////////////////
7617 TGeoPcon* ssdcableslay5pconshape[3];
7618 TGeoVolume* ssdcableslay5pcon[3];
7619 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7620 Double_t ssdcableslay5pconzsection[6];
7621 Double_t ssdcableslay5pconrmin[6];
7622 Double_t ssdcableslay5pconrmax[6];
7623 ssdcableslay5pconrmin[0] = ssdcablelay5rightubeshape->GetRmin();
7624 ssdcableslay5pconrmax[0] = ssdcablelay5rightubeshape->GetRmax();
7625 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7626 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+fgkSSDCablesLay5RightSideHeight;
7627 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7628 + fgkEndCapSupportCenterLay5Position
7629 + 2.*ssdcablelay5rightubeshape->GetDz();
7630 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7631 + fgkSSDCentralAL3SupportLength
7632 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7633 * TanD(fgkSSDPConeAngle);
7634 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7635 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7636 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7637 ssdcableslay5pconshape[0],fSSDCopper);
7638 ssdcableslay5pcon[0]->SetLineColor(9);
7639 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7640////////////////////////////////////
7641// cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7642////////////////////////////////////
7643 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7644 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7645 + fgkSSDCentralAL3SupportLength
7646 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7647 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7648 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7649 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7650 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7651 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7652 ssdcableangle,2);
7653 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7654 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7655 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7656 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7657 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7658 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3]+fgkSSDCablesLay5RightSideHeight;
7659 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7660 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7661 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7662 ssdcableslay5pcon[1]->SetLineColor(9);
7663 ////////////////////////////////////
7664 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7665 ssdcableangle,2);
7666 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7667 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7668 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7669 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7670 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7671 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7672 * TanD(fgkSSDPConeAngle)
7673 + 0.5*fgkSSDCentralSupportLength
7674 + fgkSSDCentralAL3SupportLength;
7675 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7676 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7677 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7678 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7679 ssdcableslay5pcon[2]->SetLineColor(9);
7680////////////////////////////////////
7681 TGeoRotation* ssdcableslay5pconrot[4];
7682 for(Int_t i=0; i<4; i++){
7683 ssdcableslay5pconrot[i] = new TGeoRotation();
7684 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7685 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7686 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
7687 }
7688 ////////////////////////////////////
7689 //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7690 //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7691 ////////////////////////////////////
7692 // Positioning Left SSD Cables Part
7693 ////////////////////////////////////
7694 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7695 - 0.5*ssdcablelay5rightsidelength
7696 - fgkEndCapSupportCenterLay5Position
7697 - fgkEndCapSupportCenterLay5ITSPosition);
7698 ssdcablesmother->AddNode(ssdcablelay5righttube,2,ssdcablesLay5RightTubeToLeftrans);
7699 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7700 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7701 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7702 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7703 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7704 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7705 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7706 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7707 }
7708 ////////////////////////////////////
7709 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7710 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7711 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7712 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7713 /////////////////////////////////////////////////////////////
7714 // Water Tubes Layer 5
7715 /////////////////////////
7716 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7717 ssdcableslay5rightsideradiusmax
7718 + fgkSSDCablesLay5RightSideWaterHeight,
7719 0.5*ssdcablelay5rightsidelength);
7720 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7721 ssdcablelay5rightubewatershape,
7722 fSSDCoolingTubeWater);
7723 ssdcablelay5rightwatertube->SetLineColor(7);
7724 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7725 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7726 ////////////////////////////////////
7727 // TGeoPCone Water Volumes Layer
7728 ///////////////////////////////////
7729 TGeoPcon* ssdcableslay5pconwatershape[3];
7730 TGeoVolume* ssdcableslay5pconwater[3];
7731 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7732 Double_t ssdcableslay5pconwaterzsection[6];
7733 Double_t ssdcableslay5pcwateronrmin[6];
7734 Double_t ssdcableslay5pconwaterrmax[6];
7735 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7736 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7737 + fgkSSDCablesLay5RightSideWaterHeight;
7738 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7739 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7740 + fgkSSDCablesLay5RightSideWaterHeight;
7741 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7742 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7743 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7744 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7745 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7746 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7747 ssdcableslay5pconwater[0]->SetLineColor(7);
7748 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7749 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7750////////////////////////////////////
7751 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7752 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7753 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7754 ssdcableangle,2);
7755 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7756 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7757 + fgkSSDCablesLay5RightSideWaterHeight;
7758 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7759 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7760 + fgkSSDCablesLay5RightSideWaterHeight;
7761 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7762 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7763 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7764 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7765 ssdcableslay5pconwater[1]->SetLineColor(7);
7766////////////////////////////////////
7767 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7768 ssdcableangle,2);
7769 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7770 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7771 + fgkSSDCablesLay5RightSideWaterHeight;
7772 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7773 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7774 + fgkSSDCablesLay5RightSideWaterHeight;
7775 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7776 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7777 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7778 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7779 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7780 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7781 ssdcableslay5pconwater[2]->SetLineColor(7);
7782////////////////////////////////////
7783 TGeoRotation* ssdcableslay5pconwaterot[4];
7784 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7785 for(Int_t i=0; i<4; i++){
7786 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7787 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7788 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7789 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7790 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7791 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7792 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7793 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7794 }
7795 /////////////////////////
7796 // SSD Layer 6 Cables
7797 /////////////////////////
7798 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+fgkSSDCablesLay6TubeRadiusMin;
7799 Double_t ssdcablelay6rightsidelength = 2.*ssdcablelay5rightsidelength;
7800 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+fgkSSDCablesLay6RightSideHeight;
7801 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7802 ssdcableslay6rightsideradiusmax,
7803 0.5*ssdcablelay6rightsidelength);
7804 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7805 ssdcablelay6rightubeshape,
7806 fSSDCopper);
7807 ssdcablelay6righttube->SetLineColor(9);
7808 TGeoTranslation* ssdcablelay6rightrans =
7809 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7810 + fgkEndCapSupportCenterLay6Position
7811 + 0.5*ssdcablelay6rightsidelength);
7812 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7813 - 0.5*ssdcablelay6rightsidelength
7814 - fgkEndCapSupportCenterLay6Position
7815 - fgkEndCapSupportCenterLay6ITSPosition);
7816 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7817 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7818 ////////////////////////////////////
7819 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7820 ////////////////////////////////////
7821 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7822 ssdcableangle,2);
7823 TGeoVolume* ssdcableslay6pcon;
7824 Double_t ssdcableslay6pconrmin[2];
7825 Double_t ssdcableslay6pconrmax[2];
7826 Double_t ssdcableslay6pconzsection[2];
7827 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7828 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7829 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7830 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7831 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7832 + fgkEndCapSupportCenterLay6Position
7833 + ssdcablelay6rightsidelength;
7834 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7835 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7836 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7837 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7838 ssdcableslay6pconshape,fSSDCopper);
7839 ssdcableslay6pcon->SetLineColor(9);
7840 for(Int_t i=0; i<4; i++){
7841 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7842 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7843 }
7844 ////////////////////////////////////
7845 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7846 /////////////////////////
7847 // Water Tubes Layer 6
7848 /////////////////////////
7849 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7850 ssdcableslay6rightsideradiusmax
7851 + fgkSSDCablesLay5RightSideWaterHeight,
7852 0.5*ssdcablelay6rightsidelength);
7853 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7854 ssdcablelay6righwatertubeshape,
7855 fSSDCoolingTubeWater);
7856 ssdcablelay6rightwatertube->SetLineColor(7);
7857 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7858 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7859 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7860 ssdcableangle,2);
7861 TGeoVolume* ssdcableslay6waterpcon;
7862 Double_t ssdcableslay6waterpconrmin[2];
7863 Double_t ssdcableslay6waterpconrmax[2];
7864 Double_t ssdcableslay6waterpconzsection[2];
7865 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7866 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7867 + fgkSSDCablesLay5RightSideWaterHeight;
7868 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7869 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7870 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7871 + fgkEndCapSupportCenterLay6Position
7872 + ssdcablelay6rightsidelength;
7873 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7874 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7875 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7876 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7877 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7878 ssdcableslay6waterpcon->SetLineColor(7);
7879 TGeoRotation* ssdcableslay6pconwaterot[4];
7880 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7881 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7882 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7883 for(Int_t i=0; i<4; i++){
7884 ssdcableslay6pconwaterot[i] = new TGeoRotation();
7885 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7886 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7887 * (*ssdcableslay6pconwaterot[i]));
7888 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7889 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7890 }
7891 ////////////////////////////////////////
7892 // From ITS Ring to Patch Panel3-RB26
7893 ////////////////////////////////////////
7894 Double_t ssdcablepatchpanel3BB26radiusmin[2];
7895 Double_t ssdcablepatchpanel3BB26radiusmax[2];
7896 Double_t ssdcablepatchpanel3RB26zsection[2];
fcfbdd23 7897 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeigth+2.8;
47f8de53 7898 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
7899 + fgkSSDCablesLay5RightSideHeight
7900 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
7901 ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
7902 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
7903 + 0.*fgkSSDCablesLay5RightSideHeight
7904 + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
7905 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
7906 + fgkSSDCentralAL3SupportLength
7907 + fgkSSDPConeZLength[0];
7908 ssdcablepatchpanel3RB26zsection[1] = fgkSSDPatchPanel2RB26ITSDistance;
7909 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
7910 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7911 - 0.5*ssdcableangle,ssdcableangle,2);
7912 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7913 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7914 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7915 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7916 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
7917 TGeoRotation* ssdcablepatchpanel3B26rot[3];
7918 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
7919 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
7920 ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
7921 + fgkSSDCablesPatchPanel2RB26Angle[1],0.0,0.0);
7922 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
7923 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0]
7924 + fgkSSDCablesPatchPanel2RB26Angle[1],0.0,0.0);
7925 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
7926 ////////////////////////////////////
7927 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7928 ////////////////////////////////////////
7929 // ITS Ring Cables RB26 Part
7930 ////////////////////////////////////////
7931 Double_t ssdcableitsring3BB26pconzsection[2];
7932 Double_t ssdcableitsring3BB26pconrmin[2];
7933 Double_t ssdcableitsring3BB26pconrmax[2];
7934 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7935 + fgkSSDCentralAL3SupportLength
7936 + (4.0/5.0)*fgkSSDPConeZLength[0];
7937 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
7938 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeigth;
7939 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
7940 + fgkSSDCablesLay5RightSideHeight
7941 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
7942 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7943 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7944 TGeoPcon* ssdcableitsring3BB26pconshape[4];
7945 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7946 - 0.5*ssdcableangle,ssdcableangle
7947 + (fgkSSDCablesPatchPanel2RB26Angle[0]
7948 - fgkSSDCableAngle),2);
7949 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7950 - 0.5*ssdcableangle,ssdcableangle
7951 + 3.0*fgkSSDCableAngle
7952 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7953 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-fgkSSDCablesPatchPanel2RB26Angle[0]
7954 - 0.5*ssdcableangle,ssdcableangle
7955 - fgkSSDCableAngle
7956 + fgkSSDCablesPatchPanel2RB26Angle[0],2);
7957 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7958 - 0.5*ssdcableangle,ssdcableangle
7959 + 3.0*fgkSSDCableAngle
7960 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7961 for(Int_t i=0;i<4;i++)
7962 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7963 ssdcableitsring3BB26pconrmin[j],
7964 ssdcableitsring3BB26pconrmax[j]);
7965 TGeoVolume* ssdcableitsring3BB26pcon[4];
7966 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7967 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7968 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7969 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7970 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7971 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7972 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7973 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7974 for(Int_t i=0;i<4;i++){
7975 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
5ef8864c 7976 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
47f8de53 7977}
7978 ////////////////////////////////////
7979 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7980 // + ssdcableitsring3BB26pconshape[1]->Capacity()
7981 // + ssdcableitsring3BB26pconshape[2]->Capacity()
7982 // + ssdcableitsring3BB26pconshape[3]->Capacity();
7983 ////////////////////////////////////////
7984 // From ITS Ring to Patch Panel2-RB24
7985 ////////////////////////////////////////
7986 Double_t ssdcablepatchpanel3BB24radiusmin[2];
7987 Double_t ssdcablepatchpanel3BB24radiusmax[2];
7988 Double_t ssdcablepatchpanel3RB24zsection[2];
7989 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7990 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
7991 ssdcablepatchpanel3BB24radiusmin[1] = fgkSSDPatchPanel2RB24Radius;
7992 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
7993 + 0.*fgkSSDCablesLay5RightSideHeight
7994 + 0.*fgkSSDCablesLay6RightSideHeight
7995 + 0.5*fgkSSDPatchPanelHeigth;
7996 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7997 - fgkSSDCentralAL3SupportLength
7998 - fgkSSDPConeZLength[0];
7999 ssdcablepatchpanel3RB24zsection[1] = -fgkSSDPatchPanel2RB24ITSDistance;
8000 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
8001 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
8002 - 0.5*ssdcableangle,ssdcableangle,2);
8003 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
8004 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
8005 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
8006 ssdcablepatchpanel3RB24pconshape,
8007 fSSDCopper);
8008 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
8009 TGeoRotation* ssdcablepatchpanel3B24rot[3];
8010 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
8011 ssdcablepatchpanel3B24rot[0]->SetAngles(0.0,0.0,0.0);
8012 ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0]
8013 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
8014 ssdcablepatchpanel3B24rot[2]->SetAngles(180.0,0.0,0.0);
8015 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0]
8016 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
8017 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
8018 ////////////////////////////////////
8019 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
8020 ////////////////////////////////////////
8021 // ITS Ring Cables RB24 Part
8022 ////////////////////////////////////////
8023 Double_t ssdcableitsring3BB24pconzsection[2];
8024 Double_t ssdcableitsring3BB24pconrmin[2];
8025 Double_t ssdcableitsring3BB24pconrmax[2];
8026 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
8027 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
8028 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeigth;
8029 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
8030 + fgkSSDCablesLay5RightSideHeight
8031 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeigth;
8032 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
8033 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
8034 TGeoPcon* ssdcableitsring3BB24pconshape[4];
8035 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
8036 + (90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
8037 - fgkSSDCableAngle),2);
8038 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+fgkSSDCableAngle-0.5*ssdcableangle,
8039 ssdcableangle-fgkSSDCableAngle
8040 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
8041 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
8042 - fgkSSDCableAngle
8043 + 90.0-fgkSSDCablesPatchPanel2RB24Angle[1],2);
5ef8864c 8044 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+fgkSSDCableAngle-0.5*ssdcableangle,
47f8de53 8045 ssdcableangle-fgkSSDCableAngle
8046 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
8047 for(Int_t i=0;i<4;i++)
8048 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
8049 ssdcableitsring3BB24pconrmin[j],
8050 ssdcableitsring3BB24pconrmax[j]);
8051 TGeoVolume* ssdcableitsring3BB24pcon[4];
8052 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
8053 ssdcableitsring3BB24pconshape[0],fSSDCopper);
8054 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
8055 ssdcableitsring3BB24pconshape[1],fSSDCopper);
8056 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
8057 ssdcableitsring3BB24pconshape[2],fSSDCopper);
8058 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
8059 ssdcableitsring3BB24pconshape[3],fSSDCopper);
8060 for(Int_t i=0;i<4;i++){
8061 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
5ef8864c 8062 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
47f8de53 8063}
8064 ////////////////////////////////////
8065 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
8066 // + ssdcableitsring3BB24pconshape[1]->Capacity()
8067 // + ssdcableitsring3BB24pconshape[2]->Capacity()
8068 // + ssdcableitsring3BB24pconshape[3]->Capacity();
8069 ////////////////////////////////////
8070 // Volumes for Material Budget
8071 ////////////////////////////////////
8072 TGeoTube* ssdcablelay6materialbudgetubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax
8073 + fgkSSDCablesLay5RightSideWaterHeight,
8074 ssdcableslay6rightsideradiusmax
8075 + fgkSSDCablesLay5RightSideWaterHeight
8076 + fgkSSDCableMaterialBudgetHeight,0.5*ssdcablelay6rightsidelength);
8077 TGeoVolume* ssdcablelay6materialbudgetube = new TGeoVolume("SSDCableLay6MaterialBudgetTube",
8078 ssdcablelay6materialbudgetubeshape,
8079 fSSDCopper);
8080 ssdcablelay6materialbudgetube->SetLineColor(9);
8081 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,1,ssdcablelay6rightrans);
8082 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,2,ssdcablesLay6RightTubeToLeftrans);
8083
8084 TGeoPcon* ssdcablelay6materialbudgetpconshape =
8085 new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
8086 TGeoVolume* ssdcablelay6materialbudgetpcon;
8087 Double_t ssdcablelay6materialbudgetpconrmin[2];
8088 Double_t ssdcablelay6materialbudgetpconrmax[2];
8089 Double_t ssdcablelay6materialbudgetpconzsection[2];
8090 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
8091 + fgkSSDCablesLay5RightSideWaterHeight;
8092 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
8093 + fgkSSDCableMaterialBudgetHeight;
8094 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
8095 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
8096 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
8097 + fgkEndCapSupportCenterLay6Position
8098 + ssdcablelay6rightsidelength;
8099 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
8100 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
8101 ssdcablelay6materialbudgetpconzsection[i],
8102 ssdcablelay6materialbudgetpconrmin[i],
8103 ssdcablelay6materialbudgetpconrmax[i]);
8104 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
8105 ssdcablelay6materialbudgetpconshape,fSSDCopper);
8106 ssdcablelay6materialbudgetpcon->SetLineColor(9);
8107 for(Int_t i=0; i<4; i++){
8108 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
8109 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
8110 }
8111////////////////////////////////////
8112 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
8113 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
8114 Double_t ssdcablesvolume = 0.0;
8115 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
8116 std::cout << ssdcablesvolume << std::endl;*/
8117 return ssdcablesmother;
8118 }
8119 ////////////////////////////////////////////////////////////////////////////////
d7599219 8120TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
44285dfa 8121 Double_t height, char* shapename, Int_t isign) const{
8122 /////////////////////////////////////////////////////////////
8123 // Method generating an Arb shape
8124 /////////////////////////////////////////////////////////////
8125 const Int_t kvertexnumber = 8;
8126 const Int_t ktransvectnumber = 2;
8127 TVector3* vertex[kvertexnumber];
8128 TVector3* transvector[2];
8129 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
8130 /////////////////////////////////////////////////////////////
d7599219 8131 //Setting the vertices for TGeoArb8
44285dfa 8132 /////////////////////////////////////////////////////////////
8133 vertex[0] = new TVector3(*vertexpos[0]);
8134 vertex[1] = new TVector3(*vertexpos[1]);
8135 vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
8136 vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
8137 vertex[4] = new TVector3(*vertexpos[2]);
8138 vertex[5] = new TVector3(*vertexpos[3]);
8139 vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
8140 vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
8141 /////////////////////////////////////////////////////////////
8142 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
8143 for(Int_t i = 0; i<kvertexnumber;i++)
8144 arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
bf210566 8145 /////////////////////////////////////////////////////////////
8146 // Deallocating memory
8147 /////////////////////////////////////////////////////////////
8148 for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i];
8149 for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i];
8150 /////////////////////////////////////////////////////////////
44285dfa 8151 return arbshape;
d7599219 8152}
bf210566 8153///////////////////////////////////////////////////////////////////////////////
8154TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8155 Double_t rmax, Int_t nedges, Double_t height){
8156 /////////////////////////////////////////////////////////////
8157 // Method generating Arc shape
8158 /////////////////////////////////////////////////////////////
8159 const Int_t kvertexnumber = 2*nedges+2;
8160 TGeoXtru* arcshape = new TGeoXtru(2);
8161 TVector3** vertexposition[2];
8162 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8163 Double_t angle = 0.;
8164 for(Int_t i=0; i<nedges+1; i++){
8165 angle = 90.+0.5*phi-i*(phi/nedges);
8166 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
8167 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
8168 }
8169 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8170 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8171 for(Int_t i=0; i<kvertexnumber; i++){
8172 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8173 yvertexpoints[i] = vertexposition[0][i]->Y();
8174 }
8175 else if(i>=1&&i<nedges+2)
8176 {
8177 xvertexpoints[i] = vertexposition[1][i-1]->X();
8178 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8179 }
8180 else
8181 {
8182 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8183 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8184 }
8185 }
8186 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8187 arcshape->DefineSection(0,-0.5*height);
8188 arcshape->DefineSection(1,0.5*height);
44285dfa 8189 /////////////////////////////////////////////////////////////
bf210566 8190 // Deallocating memory
44285dfa 8191 /////////////////////////////////////////////////////////////
bf210566 8192 for(Int_t i=0; i<2; i++){
8193 for(Int_t j=0; j<nedges+1; j++)
8194 delete vertexposition[i][j];
8195 delete [] vertexposition[i];
8196 }
8197 delete [] xvertexpoints;
8198 delete [] yvertexpoints;
8199 /////////////////////////////////////////////////////////////
8200 return arcshape;
d7599219 8201}
8202////////////////////////////////////////////////////////////////////////////////
9b0c60ab 8203TGeoXtru* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
8204 ///////////////////////////////////////////////////////////////////////
8205 // Method Generating the Screw Shape
8206 // radius[0]: outer radius
8207 // radius[1]: inner radius
8208 // edgesnumber[0]: outer number of edges
8209 // edgesnumber[1]: inner number of edges
8210 // section[0]: lower section position
8211 // section[1]: higher section position
8212 ///////////////////////////////////////////////////////////////////////
8213 Double_t outradius = radius[0];
8214 Double_t inradius = radius[1];
8215 Int_t outvertexnumber = edgesnumber[0];
8216 Int_t invertexnumber = edgesnumber[1];
8217 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
8218 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber+2];
8219 for(Int_t i=0; i<outvertexnumber+1; i++){
8220 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8221 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8222 }
8223 for(Int_t i=0; i<invertexnumber+1; i++){
8224 xscrewvertex[outvertexnumber+i+1] = inradius*CosD(90.-i*360./invertexnumber);
8225 yscrewvertex[outvertexnumber+i+1] = inradius*SinD(90.-i*360./invertexnumber);
8226 }
8227 TGeoXtru* screwshape = new TGeoXtru(2);
8228 screwshape->DefinePolygon(outvertexnumber+invertexnumber+2,xscrewvertex,yscrewvertex);
8229 screwshape->DefineSection(0,section[0]);
8230 screwshape->DefineSection(1,section[1]);
8231 delete [] xscrewvertex;
8232 delete [] yscrewvertex;
8233 return screwshape;
8234}
8235////////////////////////////////////////////////////////////////////////////////
8236TGeoXtru* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
8237 ///////////////////////////////////////////////////////////////////////
8238 // Method Generating the Hole Shape
8239 // radius of the Hole
8240 // nedges: number of edges to approximate the circle
8241 ///////////////////////////////////////////////////////////////////////
8242 Int_t vertexnumber = nedges+6;
8243 Double_t* xholevertex = new Double_t[vertexnumber];
8244 Double_t* yholevertex = new Double_t[vertexnumber];
8245 xholevertex[0] = radius;
8246 xholevertex[1] = xholevertex[0];
8247 xholevertex[2] = -xholevertex[1];
8248 xholevertex[3] = xholevertex[2];
8249 xholevertex[4] = xholevertex[0];
8250 yholevertex[0] = 0.;
8251 yholevertex[1] = -radius;
8252 yholevertex[2] = yholevertex[1];
8253 yholevertex[3] = -yholevertex[1];
8254 yholevertex[4] = yholevertex[3];
8255 for(Int_t i=0; i<nedges+1; i++){
8256 xholevertex[i+5] = radius*CosD(i*360./nedges);
8257 yholevertex[i+5] = radius*SinD(i*360./nedges);
8258 }
8259 TGeoXtru* holeshape = new TGeoXtru(2);
8260 holeshape->DefinePolygon(vertexnumber,xholevertex,yholevertex);
8261 holeshape->DefineSection(0,section[0]);
8262 holeshape->DefineSection(1,section[1]);
8263 delete [] xholevertex;
8264 delete [] yholevertex;
8265 return holeshape;
8266}
8267////////////////////////////////////////////////////////////////////////////////
44285dfa 8268TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
8269 /////////////////////////////////////////////////////////////
8270 // Given an axis specified by param, it gives the reflection of the point
8271 // respect to the axis
8272 /////////////////////////////////////////////////////////////
8273 TVector3* n = new TVector3(param[0],param[1],param[2]);
8274 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8275 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 8276 /////////////////////////////////////////////////////////////
8277 // Deallocating memory
8278 /////////////////////////////////////////////////////////////
8279 delete n;
8280 /////////////////////////////////////////////////////////////
44285dfa 8281 return reflectedvector;
d7599219 8282}
8283////////////////////////////////////////////////////////////////////////////////
bf210566 8284TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
d7599219 8285 Double_t dx,
8286 Double_t dy,
8287 Double_t dz) const{
44285dfa 8288 /////////////////////////////////////////////////////////////
d7599219 8289 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 8290 /////////////////////////////////////////////////////////////
bf210566 8291 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8292 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 8293 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 8294 hmatrix->SetTranslation(newvect);
8295 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8296 delete hmatrix;
8297 return matrix;
d7599219 8298}
8299////////////////////////////////////////////////////////////////////////////////
d7599219 8300TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 8301 /////////////////////////////////////////////////////////////
8302 // Method returning the Medium type
8303 /////////////////////////////////////////////////////////////
d7599219 8304 char ch[30];
8305 sprintf(ch, "ITS_%s",mediumName);
8306 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8307 if (! medium)
8308 printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
8309 return medium;
8310}
8311////////////////////////////////////////////////////////////////////////////////
d7599219 8312void AliITSv11GeometrySSD::CreateMaterials(){
8313///////////////////////////////////
8314// This part has to be modified
8315///////////////////////////////////
8316 ///////////////////////////////////
8317 // Silicon for Sensor
8318 ///////////////////////////////////
bf210566 8319 fSSDSensorMedium = GetMedium("SI$");
d7599219 8320 ///////////////////////////////////
8321 // Silicon Mixture for Sensor
8322 ///////////////////////////////////
44285dfa 8323 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8324 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 8325 ///////////////////////////////////
8326 // Stiffener Components Materials
8327 ///////////////////////////////////
bf210566 8328 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 8329 ///////////////////////////
8330 // Stiffener Connectors
8331 ///////////////////////////
bf210566 8332 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 8333 ////////////////////////////////
8334 // Stiffener 0603-1812 Capacitor
8335 ////////////////////////////////
bf210566 8336 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8337 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
d7599219 8338 ///////////////////////////
8339 // Stiffener Hybrid Wire
8340 ///////////////////////////
bf210566 8341 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 8342 ///////////////////////////
8343 // Al for Cooling Block
8344 ///////////////////////////
bf210566 8345 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 8346 //////////////////////////////////////////////////////
8347 // Kapton and Al for Chip Cable Flex and Ladder Cables
8348 //////////////////////////////////////////////////////
bf210566 8349 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8350 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8351 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8352 fSSDAlTraceFlexMedium = GetMedium("AL$");
8353 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8354 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 8355 /////////////////////////////////////////////////////////////////
8356 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8357 //////////////////////////////////////////////////////////////////
44285dfa 8358 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 8359 /////////////////////////////////////////////////////////////////
8360 // G10 for Detector Leg, TubeHolder
8361 //////////////////////////////////////////////////////////////////
44285dfa 8362 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8363 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8364 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8365 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 8366 /////////////////////////////////////////////////////////////////
8367 // Water and Phynox for Cooling Tube
8368 //////////////////////////////////////////////////////////////////
bf210566 8369 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 8370 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 8371 /////////////////////////////////////////////////////////////////////
9b0c60ab 8372 // Material for Support Rings
8373 /////////////////////////////////////////////////////////////////////
8374 fSSDSupportRingAl = GetMedium("AL$");
47f8de53 8375 fSSDRohaCellCone = GetMedium("ROHACELL$");
9b0c60ab 8376 /////////////////////////////////////////////////////////////////////
bf210566 8377 fSSDAir = GetMedium("SDD AIR$");
47f8de53 8378 fSSDCopper = GetMedium("COPPER$");
bf210566 8379 fCreateMaterials = kTRUE;
d7599219 8380}
8381/////////////////////////////////////////////////////////////////////