]> 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
Fix in plugin creation
[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySSD.cxx
CommitLineData
d7599219 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
5ef8864c 16/* $Id$ */
d7599219 17
18//*************************************************************************
19// SSD geometry, based on ROOT geometrical modeler
20//
21// Enrico Cattaruzza ecattar@ts.infn.it
22//*************************************************************************
23#include "TMath.h"
24#include "TGeoVolume.h"
d7599219 25#include "TGeoMatrix.h"
26#include <TGeoManager.h>
d7599219 27#include "TVector3.h"
28#include "TGeoArb8.h"
29#include "TList.h"
30#include "TGeoMatrix.h"
31#include "TGeoCompositeShape.h"
851c0ce3 32#include "TGeoBoolNode.h"
d7599219 33#include "TGeoTube.h"
34#include "TGeoBBox.h"
bf210566 35#include "TGeoXtru.h"
9b0c60ab 36#include "TGeoTorus.h"
37#include "TGeoPgon.h"
47f8de53 38#include "TGeoPcon.h"
9b0c60ab 39#include "TRotation.h"
44285dfa 40#include "AliITSv11GeometrySSD.h"
78e34526 41
d7599219 42/////////////////////////////////////////////////////////////////////////////////
bf210566 43// Names of the Sensitive Volumes of Layer 5 and Layer 6
44/////////////////////////////////////////////////////////////////////////////////
f510fd70 45const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName5 = "ITSssdSensitivL5";
46const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName6 = "ITSssdSensitivL6";
bf210566 47/////////////////////////////////////////////////////////////////////////////////
d7599219 48//Parameters for SSD Geometry
49/////////////////////////////////////////////////////////////////////////////////
e21cdd03 50// Variable for Vertical Disalignement of Modules
51/////////////////////////////////////////////////////////////////////////////////
ca86fdb4 52const Double_t AliITSv11GeometrySSD::fgkSSDTolerance = 0.0001*fgkmm;
0fb26117 53const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
54const Double_t AliITSv11GeometrySSD::fgkSSDModuleSideDisalignment = 0.2*fgkmm;
160835d5 55// For ladders:
cd2243fb 56const Double_t AliITSv11GeometrySSD::fgkSSDLadderVerticalDisalignment = 0.520*fgkmm;
e21cdd03 57/////////////////////////////////////////////////////////////////////////////////
d7599219 58// Layer5 (lengths are in mm and angles in degrees)
59/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 60const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
d7599219 61const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
62const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
9acf2ecc 63const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
64const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
65const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
d7599219 66/////////////////////////////////////////////////////////////////////////////////
67// Layer6 (lengths are in mm and angles in degrees)
68/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 69const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
d7599219 70const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
71const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
9acf2ecc 72const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
73const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
74const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
d7599219 75/////////////////////////////////////////////////////////////////////////////////
76// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
77/////////////////////////////////////////////////////////////////////////////////
78const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
9acf2ecc 79const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
80const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
81const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
82const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
bf210566 83const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
84const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
9acf2ecc 85const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
d7599219 86/////////////////////////////////////////////////////////////////////////////////
87// Stiffener (lengths are in mm and angles in degrees)
88/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 89const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
90const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
78e34526 91const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.295*fgkmm;
9acf2ecc 92const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
78e34526 93const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603CapLength = 0.900*fgkmm; // Includes solder
bf210566 94const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
9acf2ecc 95const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
96const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
78e34526 97const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812CapLength = 0.215*fgkmm;
9acf2ecc 98const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
99const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
78e34526 100const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 1.400*fgkmm;
9acf2ecc 101const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
102const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
78e34526 103const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] = {44.32*fgkmm, 0.33*fgkmm};
bf210566 104const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
105const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
106const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
78e34526 107const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight = 0.25*fgkSSDStiffenerHeight;
bf210566 108const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
109const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
78e34526 110const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSnHeight = 0.15*fgkmm;
d7599219 111/////////////////////////////////////////////////////////////////////////////////
112// Cooling Block (lengths are in mm and angles in degrees)
113/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 114const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
115const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
bf210566 116const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
117 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
d7599219 118const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
78e34526 119 {1.025*fgkmm, 0.120*fgkmm}; // Added 50 micron tolerance for thicker wall cooling pipe (March 2010)
d7599219 120const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
bf210566 121 {1.900*fgkmm, 0.400*fgkmm};
d7599219 122const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
9acf2ecc 123 1.500*fgkmm;
d7599219 124const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
9acf2ecc 125 0.300*fgkmm;
d7599219 126/////////////////////////////////////////////////////////////////////////////////
127// SSD Sensor (lengths are in mm and angles in degrees)
128/////////////////////////////////////////////////////////////////////////////////
129const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
bf210566 130 "SSDSensorSensitiveVol";
9acf2ecc 131const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
132const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
133const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
d7599219 134const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
9acf2ecc 135 fgkSSDSensorLength-39.1*fgkmm;
bf210566 136const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
137const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
d7599219 138/////////////////////////////////////////////////////////////////////////////////
139// Flex (lengths are in mm and angles in degrees)
140/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 141const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
d7599219 142const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
bf210566 143 {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
144 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
145 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
146 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
147 - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
d7599219 148const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
bf210566 149 { 9.340*fgkmm, 5.380*fgkmm};
d7599219 150const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
bf210566 151 { 0.030*fgkmm, 0.020*fgkmm};
d7599219 152const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
9acf2ecc 153const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
154const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
d7599219 155const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
bf210566 156 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
d7599219 157const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
bf210566 158 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
d7599219 159/////////////////////////////////////////////////////////////////////////////////
160// SSD Ladder Cable (lengths are in mm and angles in degrees)
161/////////////////////////////////////////////////////////////////////////////////
bf210566 162const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
78e34526 163const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableHeight[2] = { 0.030*fgkmm*17.5/23.5, 1.25 * 0.030*fgkmm}; // Al covers ~ 17.5/23.5 of surface, Kapton includes glue+foam
d7599219 164/////////////////////////////////////////////////////////////////////////////////
165// SSD Module (lengths are in mm and angles in degrees)
166/////////////////////////////////////////////////////////////////////////////////
167const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
bf210566 168 { 1.000*fgkmm, 3.900*fgkmm};
d7599219 169const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
9acf2ecc 170 45.600*fgkmm;
d7599219 171const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
9acf2ecc 172 5.075*fgkmm;
d7599219 173/////////////////////////////////////////////////////////////////////////////////
174// Sensor Support (lengths are in mm and angles in degrees)
175/////////////////////////////////////////////////////////////////////////////////
bf210566 176const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
177 5.800*fgkmm;
d7599219 178const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
bf210566 179 2.000*fgkmm;
d7599219 180const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
0fb26117 181 { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment,
182 5.220*fgkmm-fgkSSDModuleVerticalDisalignment};
ca86fdb4 183//const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
184// { 4.520*fgkmm, 5.130*fgkmm};
bf210566 185const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
186 { 0.450*fgkmm, 0.450*fgkmm};
187const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
188 = 0.5 * (fgkSSDModuleSensorSupportDistance
189 + fgkSSDSensorSideSupportThickness[0])
190 - fgkSSDSensorSideSupportLength;
d7599219 191const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
bf210566 192 5.250*fgkmm;
d7599219 193const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
bf210566 194 1.680*fgkmm;
195const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
196 = {fgkSSDSensorSideSupportHeight[0]
197 + fgkSSDSensorSideSupportThickness[0],
198 fgkSSDSensorSideSupportHeight[1]
199 + fgkSSDSensorSideSupportThickness[1]};
200const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
201 = {fgkSSDSensorSideSupportThickness[0],
202 fgkSSDSensorSideSupportThickness[1]};
d7599219 203const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
bf210566 204 19.000*fgkmm;
d7599219 205/////////////////////////////////////////////////////////////////////////////////
206// Chip Cables (lengths are in mm and angles in degrees)
207/////////////////////////////////////////////////////////////////////////////////
208const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
bf210566 209 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
d7599219 210const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
bf210566 211 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
212 - (fgkSSDSensorSideSupportHeight[1]
213 - fgkSSDSensorSideSupportHeight[0])
0fb26117 214 - fgkSSDModuleVerticalDisalignment
bf210566 215 - fgkSSDCoolingBlockHoleCenter
216 - fgkSSDStiffenerHeight
217 - fgkSSDChipHeight-fgkSSDSensorHeight,
218 fgkSSDModuleCoolingBlockToSensor
0fb26117 219 - fgkSSDModuleVerticalDisalignment
bf210566 220 - fgkSSDCoolingBlockHoleCenter
221 - fgkSSDStiffenerHeight
222 - fgkSSDChipHeight-fgkSSDSensorHeight};
d7599219 223const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
bf210566 224 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
d7599219 225/////////////////////////////////////////////////////////////////////////////////
226// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
227/////////////////////////////////////////////////////////////////////////////////
228const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
bf210566 229 3.820*fgkmm;
230//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
231// 3.780;
d7599219 232const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
bf210566 233 fgkSSDSensorLength-fgkSSDSensorOverlap;
d7599219 234const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
bf210566 235 { 0.86*fgkmm, 0.30*fgkmm};
d7599219 236const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
bf210566 237 { 30.00, 90.00};
d7599219 238const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
bf210566 239 1.78*fgkmm;
d7599219 240/////////////////////////////////////////////////////////////////////////////////
241//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
242/////////////////////////////////////////////////////////////////////////////////
bf210566 243const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
244 = fgkSSDModuleSensorSupportDistance
245 - 2. * fgkCarbonFiberJunctionToSensorSupport;
246const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
d7599219 247const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
bf210566 248 { 0.751*fgkmm, 0.482*fgkmm};
249const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
250 1.630*fgkmm;
251const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
252const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
253 = fgkCarbonFiberTriangleLength
254 - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
255 / TMath::Cos(fgkCarbonFiberTriangleAngle
256 * TMath::DegToRad());
257const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
258 = 0.5*(fgkCarbonFiberJunctionWidth
259 - fgkCarbonFiberSupportWidth)
260 - fgkCarbonFiberSupportTopEdgeDist[0]
261 - fgkCarbonFiberSupportWidth;
d7599219 262/////////////////////////////////////////////////////////////////////////////////
263// Carbon Fiber Lower Support Parameters (lengths are in mm)
264/////////////////////////////////////////////////////////////////////////////////
c40ebacc 265const Double_t AliITSv11GeometrySSD::fgkLowerSupportToSensorZ = 11.575*fgkmm;
d7599219 266const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
9acf2ecc 267 = 0.950*fgkmm;
d7599219 268const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
9acf2ecc 269 = 1.600*fgkmm;
d7599219 270const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
9acf2ecc 271 = 0.830*fgkmm;
d7599219 272const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
273 = 0.5*fgkCarbonFiberSupportWidth;
274const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
bf210566 275 = fgkCarbonFiberJunctionWidth
276 - 2. * (fgkCarbonFiberLowerSupportWidth
277 + fgkCarbonFiberLowerSupportVolumeSeparation);
d7599219 278const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
bf210566 279 = {fgkCarbonFiberLowerSupportWidth
280 + fgkCarbonFiberLowerSupportVolumeSeparation,
281 fgkCarbonFiberLowerSupportWidth
282 + fgkCarbonFiberLowerSupportVolumeSeparation
283 + fgkCarbonFiberLowerSupportTransverseWidth};
d7599219 284/////////////////////////////////////////////////////////////////////////////////
285// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
286/////////////////////////////////////////////////////////////////////////////////
287const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
bf210566 288 {0.5 * (fgkSSDLay5LadderLength
289 - fgkSSDLay5SensorsNumber
290 * fgkCarbonFiberJunctionWidth
291 - fgkCarbonFiberLowerSupportWidth),
292 0.5 * (fgkSSDLay5LadderLength
293 - fgkSSDLay5SensorsNumber
294 * fgkCarbonFiberJunctionWidth
295 + fgkCarbonFiberLowerSupportWidth)};
d7599219 296const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
bf210566 297 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
298 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
d7599219 299const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
bf210566 300 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
301 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
9b0c60ab 302const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
303 {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
d7599219 304/////////////////////////////////////////////////////////////////////////////////
305// Cooling Tube Support (lengths are in mm and angles in degrees)
306/////////////////////////////////////////////////////////////////////////////////
bf210566 307const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
d7599219 308const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
309 = fgkSSDCoolingBlockHoleRadius[0];
bf210566 310const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
311const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
312const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
d7599219 313const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
bf210566 314 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
315const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
316 11.70*fgkmm;
d7599219 317/////////////////////////////////////////////////////////////////////////////////
318// Cooling Tube (lengths are in mm and angles in degrees)
319/////////////////////////////////////////////////////////////////////////////////
bf210566 320const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
78e34526 321const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 1.915*fgkmm/2; // Nominal + 50 micron tolerance; real pipes are closer to 450 micron wall thickness
bf210566 322const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
d7599219 323 fgkCarbonFiberJunctionWidth;
324const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
bf210566 325 fgkSSDModuleSensorSupportDistance
326 + fgkSSDCoolingBlockLength;
9b0c60ab 327const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
d7599219 328/////////////////////////////////////////////////////////////////////////////////
329// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
330/////////////////////////////////////////////////////////////////////////////////
331const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
bf210566 332 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
d7599219 333const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
bf210566 334 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
d7599219 335const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
bf210566 336 20.0*fgkmm;
d7599219 337const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
bf210566 338 40.0;
d7599219 339const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
340 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
341const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
bf210566 342 2.5*fgkmm;
d7599219 343const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
bf210566 344 { 56.0*fgkmm, 12.0*fgkmm};
d7599219 345const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
bf210566 346 { 5.0*fgkmm, 2.9*fgkmm};
d7599219 347const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
bf210566 348 1.0*fgkmm;
d7599219 349const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
bf210566 350 6.0*fgkmm;
cd2243fb 351const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeight =
bf210566 352 4.0*fgkmm;
d7599219 353const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
bf210566 354 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
d7599219 355/////////////////////////////////////////////////////////////////////////////////
9b0c60ab 356// SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
357/////////////////////////////////////////////////////////////////////////////////
358const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
359const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
360const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
361const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
362const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
363/////////////////////////////////////////////////////////////////////////////////
364// SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
365/////////////////////////////////////////////////////////////////////////////////
366const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
367const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
368const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
369 - fgkSSDMountingBlockHeight[1]
370 + 0.5*fgkCoolingTubeSupportHeight
371 + fgkSSDModuleCoolingBlockToSensor
372 - fgkMountingBlockSupportDownHeight,
373 fgkSSDLay6RadiusMin
374 - fgkSSDMountingBlockHeight[1]
375 + 0.5*fgkCoolingTubeSupportHeight
376 + fgkSSDModuleCoolingBlockToSensor
377 - fgkMountingBlockSupportDownHeight};
378const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
379 - fgkSSDMountingBlockHeight[1]
380 + 0.5*fgkCoolingTubeSupportHeight
381 + fgkSSDModuleCoolingBlockToSensor
382 - fgkMountingBlockSupportRadius[0],
383 fgkSSDLay6RadiusMax
384 - fgkSSDMountingBlockHeight[1]
385 + 0.5*fgkCoolingTubeSupportHeight
386 + fgkSSDModuleCoolingBlockToSensor
387 - fgkMountingBlockSupportRadius[1]};
cd2243fb 388const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeight = 10.0*fgkmm; // To be verified
9b0c60ab 389const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
390const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
391/////////////////////////////////////////////////////////////////////////////////
392// SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
393/////////////////////////////////////////////////////////////////////////////////
394const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
395const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
396const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
397const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
398 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
399const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
400 {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
401const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
402 {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
403const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
404const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
405const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
406const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
407const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
408const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
409/////////////////////////////////////////////////////////////////////////////////
410// SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
411/////////////////////////////////////////////////////////////////////////////////
412const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
413const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
414const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
415/////////////////////////////////////////////////////////////////////////////////
416// SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
417/////////////////////////////////////////////////////////////////////////////////
418const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
419 {10.5*fgkmm,9.25*fgkmm};
420const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
421const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
422const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
423 {182.3,177.9,84.4,70.0,35.0};
424const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
425 {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
426const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
427/////////////////////////////////////////////////////////////////////////////////
428// SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
429/////////////////////////////////////////////////////////////////////////////////
430const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
431 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
432const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
433 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
434 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
435const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
436/////////////////////////////////////////////////////////////////////////////////
437// SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
438/////////////////////////////////////////////////////////////////////////////////
439const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
440 {62.0*fgkmm,21.87*fgkmm};
441const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
7708d5f3 442 {47.0*fgkmm,0.35*fgkmm};
9b0c60ab 443const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
444 1.0*fgkmm;
445const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
446const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
447 {43.5*fgkmm, 0.70*fgkmm};
448const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
449 0.15*fgkmm;
450const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
451 19.0*fgkmm;
452const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
453 {4.80*fgkmm,1.1*fgkmm};
454const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
455 {3.3*fgkmm,1.10*fgkmm};
456const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
457 2.1*fgkmm;
458const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
459 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
460const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
461 {1.9*fgkmm,0.15*fgkmm};
462const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
463 19*fgkmm;
464const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
465 1.0*fgkmm;
466const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
467 3.6*fgkmm;
468const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
469 61.0*fgkmm;
470const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
471 5.97*fgkmm;
472const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
473const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
474 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
475 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
476const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
477 {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
478const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
479 1.0*fgkmm;
480const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
481 = 0.15*fgkmm;
482const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
483 20.0*fgkmm;
484const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
485const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
486const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
487const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
488const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
489/////////////////////////////////////////////////////////////////////////////////
490// SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
491/////////////////////////////////////////////////////////////////////////////////
492const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
493const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
47f8de53 494const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {375.0*fgkmm,435.0*fgkmm};
9b0c60ab 495const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
496const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
5d9d4033 497const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 624.9*fgkmm;
9b0c60ab 498const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
499const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
500const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
501/////////////////////////////////////////////////////////////////////////////////
47f8de53 502// SSD Cone Parameters (lengths are in mm and angles in degrees)
503/////////////////////////////////////////////////////////////////////////////////
504const Double_t AliITSv11GeometrySSD::fgkSSDLowerPConeRadius = 296.5*fgkmm;
505const Double_t AliITSv11GeometrySSD::fgkSSDPConeAngle = 39.0;
fcfbdd23 506const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {168.0*fgkmm,153.0*fgkmm};
47f8de53 507const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleRadius = 317.5*fgkmm;
508const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleLength = 20.*fgkmm;
509const Double_t AliITSv11GeometrySSD::fgkSSDConeMiddleRadius = 350.*fgkmm;
510const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleLength = 30.*fgkmm;
511const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleWidth = 40.*fgkmm;
512const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpRadius = 400.*fgkmm;
fcfbdd23 513const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 459.*fgkmm;
47f8de53 514const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMiddleRadius = 472.5*fgkmm;
515const Double_t AliITSv11GeometrySSD::fgkSSDPConeDownRadius = 282.0*fgkmm;
516const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidAngle = 42.0;
517const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidBasis = 200.0*fgkmm;
518const Double_t AliITSv11GeometrySSD::fgkSSDPConeExternalRadius = 492.5*fgkmm;
519const Double_t AliITSv11GeometrySSD::fgkSSDPConeRadiusWidth = 16.75*fgkmm;
fcfbdd23 520const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 168.0*fgkmm;
47f8de53 521const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportLength = 1020.*fgkmm;
522const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm;
523const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm;
524const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportLength = 60.0*fgkmm;
525const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportWidth = 2.5*fgkSSDCentralSupportWidth;
526/////////////////////////////////////////////////////////////////////////////////
527// SSD Cables Parameters (lengths are in mm and angles in degrees)
528/////////////////////////////////////////////////////////////////////////////////
529const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
530const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
531const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
532const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
533const Double_t AliITSv11GeometrySSD::fgkSSDCableAngle = 22.5;
534const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm; // to be fixed in order to reproduce material budget
535const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
536const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
537const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
538const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
539const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = 451.3*fgkmm;
540const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = 451.3*fgkmm;
cd2243fb 541const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeight = 87.5*fgkmm;
47f8de53 542const Double_t AliITSv11GeometrySSD::fgkSSDCableMaterialBudgetHeight = 20.0*fgkmm;
543//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = fgkSSDPConeExternalRadius;
544//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = fgkSSDPConeExternalRadius;
545/////////////////////////////////////////////////////////////////////////////////
44285dfa 546ClassImp(AliITSv11GeometrySSD)
547/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 548AliITSv11GeometrySSD::AliITSv11GeometrySSD():
549 AliITSv11Geometry(),
44285dfa 550 fSSDChipMedium(),
551 fSSDChipGlueMedium(),
552 fSSDStiffenerMedium(),
553 fSSDStiffenerConnectorMedium(),
554 fSSDStiffener0603CapacitorMedium(),
555 fSSDStiffener1812CapacitorMedium(),
78e34526 556 fSSDStiffenerCapacitorCapMedium(),
44285dfa 557 fSSDStiffenerHybridWireMedium(),
558 fSSDKaptonFlexMedium(),
559 fSSDAlTraceFlexMedium(),
560 fSSDAlTraceLadderCableMedium(),
561 fSSDKaptonLadderCableMedium(),
562 fSSDKaptonChipCableMedium(),
563 fSSDAlTraceChipCableMedium(),
564 fSSDAlCoolBlockMedium(),
565 fSSDSensorMedium(),
566 fSSDSensorSupportMedium(),
567 fSSDCarbonFiberMedium(),
568 fSSDTubeHolderMedium(),
569 fSSDCoolingTubeWater(),
570 fSSDCoolingTubePhynox(),
9b0c60ab 571 fSSDSupportRingAl(),
44285dfa 572 fSSDMountingBlockMedium(),
47f8de53 573 fSSDRohaCellCone(),
bf210566 574 fSSDAir(),
47f8de53 575 fSSDCopper(),
78e34526 576 fSSDSn(),
bf210566 577 fCreateMaterials(kFALSE),
578 fTransformationMatrices(kFALSE),
579 fBasicObjects(kFALSE),
580 fcarbonfiberjunction(),
581 fcoolingtubesupport(),
582 fhybridmatrix(),
583 fssdcoolingblocksystem(),
584 fcoolingblocksystematrix(),
585 fssdstiffenerflex(),
586 fssdendflex(),
cd2243fb 587 fcoolingtube(0),
9b0c60ab 588 fendladdercoolingtubesupportmatrix(),
bf210566 589 fendladdermountingblock(),
9b0c60ab 590 fendladdermountingblockclip(),
bf210566 591 fSSDSensor5(),
592 fSSDSensor6(),
593 fSSDLayer5(),
594 fSSDLayer6(),
595 fMotherVol(),
9b0c60ab 596 fLay5LadderSupportRing(),
597 fLay6LadderSupportRing(),
e5bf64ae 598 fgkEndCapSupportSystem(),
47f8de53 599 fSSDCone(),
44285dfa 600 fColorCarbonFiber(4),
601 fColorRyton(5),
bf210566 602 fColorPhynox(14),
44285dfa 603 fColorSilicon(3),
bf210566 604 fColorAl(38),
78e34526 605 fColorNiSn(40),
44285dfa 606 fColorKapton(6),
607 fColorPolyhamide(5),
608 fColorStiffener(9),
bf210566 609 fColorEpoxy(30),
610 fColorWater(7),
611 fColorG10(41)
44285dfa 612{
613 ////////////////////////
614 // Standard constructor
615 ////////////////////////
705f5cb5 616 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++){
617 fendladdermountingblockcombitrans[i] = NULL;
618 }
045be90c 619 for (Int_t i=0; i < fgkcarbonfibersupportnumber; i++) {
620 fcarbonfibersupport[i] = 0;
621 fcarbonfibersupportmatrix[i] = 0;
622 }
623 for (Int_t i=0; i < fgkcarbonfiberjunctionumber; i++) {
624 fcarbonfiberjunctionmatrix[i] = 0;
625 }
626 for (Int_t i=0; i < fgkcarbonfiberlowersupportnumber; i++) {
627 fcarbonfiberlowersupport[i] = 0;
628 fcarbonfiberlowersupportrans[0] = 0;
629 }
630 for (Int_t i=0; i < fgkvolumekind; i++) {
631 fssdsensorsupport[i] = 0;
632 }
633 for (Int_t i=0; i < fgkssdsensorsupportnumber; i++) {
634 fssdsensorsupportmatrix[i] = 0;
635 }
636 for (Int_t i=0; i < fgkcoolingtubesupportnumber; i++) {
637 fcoolingtubesupportmatrix[i] = 0;
638 }
639 for (Int_t i=0; i < fgkhybridcompnumber; i++) {
640 fssdhybridcomponent[i] = 0;
641 }
642 for (Int_t i=0; i < fgkcoolingblocknumber; i++) {
643 fcoolingblockmatrix[i] = 0;
644 }
645 for (Int_t i=0; i < fgkflexnumber; i++) {
646 fstiffenerflexmatrix[i] = 0;
647 fendflexmatrix[i] = 0;
648 }
649 for (Int_t i=0; i < fgkendladdercoolingtubenumber; i++) {
650 fendladdercoolingtube[i] = 0;
651 for (Int_t j = 0; j < 2; j++)
652 fendladdercoolingtubematrix[i][j] = 0;
653 }
654 for (Int_t i=0; i < fgkendlabbercarbonfiberjunctionumber; i++) {
655 fendladdercarbonfiberjunction[i] = 0;
656 }
b28b5356 657 for (Int_t i=0; i < fgkendladdercarbonfiberjunctionmatrixnumber; i++) {
045be90c 658 fendladdercarbonfiberjunctionmatrix[i] = 0;
659 }
660 for (Int_t i=0; i < fgkendladdercarbonfibermatrixnumber; i++) {
661 fendladdercarbonfibermatrix[i] = 0;
662 }
663 for (Int_t i=0; i < fgkendladdermountingblocknumber; i++) {
664 fendladdermountingblockclipmatrix[i] = 0;
665 }
666 for (Int_t i = 0; i < fgkendladderlowersuppnumber+1; i++) {
667 fendladderlowersupptrans[i] = 0;
668 }
669 for (Int_t i = 0; i < fgkladdercablesnumber; i++) {
670 fladdercablematrix[i] = 0;
671 }
672 for (Int_t i = 0; i < fgkladdersegmentnumber; i++) {
673 fladdersegment[i] = 0;
674 }
675 for (Int_t i = 0; i < fgkladdernumber; i++) {
676 fladder[i] = 0;
677 fladdermatrix[i] = 0;
678 fssdsensormatrix[i] = 0;
679 flayermatrix[i] = 0;
680 }
681 for (Int_t i = 0; i < 2; i++) {
682 fLay5LadderSupport[i] = 0;
683 fLay6LadderSupport[i] = 0;
705f5cb5 684 fcoolingtubematrix[i] = NULL;
685 fendladdersegment[i] = NULL;
686 fendladdersegmentmatrix[i] = NULL;
045be90c 687 }
44285dfa 688}
705f5cb5 689
bf210566 690///////////////////////////////////////////////////////////////////////////////
691void AliITSv11GeometrySSD::CreateTransformationMatrices(){
692 ///////////////////////////////////////////////////////////////////////
693 // Method generating the trasformation matrix for the whole SSD Geometry
694 ///////////////////////////////////////////////////////////////////////
695 // Setting some variables for Carbon Fiber Supportmatrix creation
696 //////////////////////////////////////////////////////////////////////
697 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
698 * CosD(fgkCarbonFiberJunctionAngle[0]);
699 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
700 + fgkCarbonFiberSupportTopEdgeDist[0]
701 + fgkCarbonFiberSupportWidth);
702 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
703 * TanD(fgkCarbonFiberJunctionAngle[0]);
704 TGeoRotation* carbonfiberot[3];
705 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
706 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
707 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
708 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
709 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
710 * CosD(fgkCarbonFiberTriangleAngle),0.,
711 - fgkCarbonFiberTriangleLength
712 * SinD(fgkCarbonFiberTriangleAngle)};
713 ///////////////////////////////////////////
714 //Setting Local Translations and Rotations:
715 ///////////////////////////////////////////
716 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
717 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
718 0.5*carbonfibersupportheight,NULL);
719 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
720 2.*symmetryplaneposition+transvector[1],
721 transvector[2], carbonfiberot[2]);
722 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
723 /////////////////////////////////////////////////////////////
724 // Carbon Fiber Support Transformations
725 /////////////////////////////////////////////////////////////
726 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
727 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
728 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
729 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
730 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
731 }
732 /////////////////////////////////////////////////////////////
733 // Carbon Fiber Junction Transformation
734 /////////////////////////////////////////////////////////////
735 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
736 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
737 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
738 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
739 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
740 localcarbonfiberjunctionmatrix[i] =
741 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
742 localcarbonfiberjunctionrot[i] =
743 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
744 localcarbonfiberjunctiontrans[i] =
745 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 746 }
bf210566 747 ///////////////////////
748 // Setting Translations
749 ///////////////////////
750 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
751 localcarbonfiberjunctiontrans[1][0] =
752 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
753 localcarbonfiberjunctiontrans[2][0] =
754 new TGeoTranslation(fgkCarbonFiberTriangleLength
755 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
756 fgkCarbonFiberTriangleLength
757 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
758 localcarbonfiberjunctiontrans[0][1] =
759 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
760 localcarbonfiberjunctiontrans[1][1] =
761 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
762 localcarbonfiberjunctiontrans[2][1] =
763 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
764 ////////////////////
765 // Setting Rotations
766 ////////////////////
767 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
768 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
769 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
770 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
771 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
772 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
773 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
774 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
775 ////////////////////////////////////////
776 // Setting Carbon Fiber Junction matrix
777 ////////////////////////////////////////
778 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
779 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
780 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
781 localcarbonfiberjunctionmatrix[i][j] =
782 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
783 *localcarbonfiberjunctionrot[i][j]);
784 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
785 }
d7599219 786 }
bf210566 787 /////////////////////////////////////////////////////////////
788 // Carbon Fiber Lower Support Transformations
789 /////////////////////////////////////////////////////////////
790 TGeoTranslation* localcarbonfiberlowersupportrans[2];
791 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
792 fgkCarbonFiberLowerSupportVolumePosition[1]
793 + fgkCarbonFiberLowerSupportVolumePosition[0],
794 0.0);
795 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
796 fgkCarbonFiberJunctionWidth
797 - fgkCarbonFiberLowerSupportWidth
798 - fgkCarbonFiberLowerSupportVolumePosition[0]
799 - fgkCarbonFiberLowerSupportVolumePosition[1],
800 - 0.5*fgkCarbonFiberLowerSupportHeight);
801 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
802 fcarbonfiberlowersupportrans[0] =
803 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
804 fcarbonfiberlowersupportrans[1] =
805 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
806 /////////////////////////////////////////////////////////////
807 // SSD Sensor Support Transformations
808 /////////////////////////////////////////////////////////////
809 const Int_t kssdsensorsupportmatrixnumber = 3;
810 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
811 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
812 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
813 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
814 localssdsensorsupportmatrix[i] =
815 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
816 localssdsensorsupportrot[i] =
817 new TGeoRotation*[kssdsensorsupportmatrixnumber];
818 localssdsensorsupportrans[i] =
819 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 820 }
bf210566 821 ///////////////////////
822 // Setting Translations
823 ///////////////////////
824 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
825 0.5*fgkSSDSensorSideSupportWidth,
826 0.0);
827 localssdsensorsupportrans[1][0] =
828 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
829 localssdsensorsupportrans[2][0] =
830 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
831 localssdsensorsupportrans[0][1] =
832 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
833 0.5*fgkSSDSensorSideSupportThickness[0],
834 0.0);
835 localssdsensorsupportrans[1][1] =
836 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
837 - 0.5*fgkSSDSensorSideSupportThickness[0]
838 - fgkSSDModuleSensorSupportDistance,
839 0.0);
840 localssdsensorsupportrans[2][1] =
841 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
842 - fgkSSDSensorCenterSupportPosition,
843 0.5*fgkSSDSensorCenterSupportWidth
844 - 0.5*fgkSSDModuleSensorSupportDistance,
845 fgkSSDSensorCenterSupportThickness[0]);
846 localssdsensorsupportrans[0][2] =
847 new TGeoTranslation(fgkCarbonFiberTriangleLength
848 + fgkCarbonFiberJunctionToSensorSupport,
849 fgkCarbonFiberJunctionWidth
850 - 0.5*(fgkCarbonFiberLowerSupportWidth
851 + fgkSSDSensorCenterSupportLength
852 - fgkSSDSensorCenterSupportThickness[0])
853 - fgkSSDSensorCenterSupportPosition,
854 0.0);
855 localssdsensorsupportrans[1][2] =
856 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
857 localssdsensorsupportrans[2][2] =
858 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
859 ////////////////////
860 // Setting Rotations
861 ////////////////////
862 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
863 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
864 localssdsensorsupportrot[i][j] = new TGeoRotation();
865 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
866 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
867 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 868 }
bf210566 869 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
870 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
871 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
872 ////////////////////////////////////////
873 // SSD Sensor Support matrix
874 ////////////////////////////////////////
875 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
876 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
877 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
878 localssdsensorsupportmatrix[i][j] =
879 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
880 *localssdsensorsupportrot[i][j]);
881 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
882 }
d7599219 883 }
44285dfa 884 /////////////////////////////////////////////////////////////
bf210566 885 // SSD Cooling Tube Support Transformations
44285dfa 886 /////////////////////////////////////////////////////////////
bf210566 887 const Int_t kcoolingtubesupportmatrixnumber = 2;
888 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
889 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
890 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 891 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 892 /fgkCoolingTubeSupportRmax);
bf210566 893 localcoolingtubesupportrans[0] =
894 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 895 + 2.*(fgkCoolingTubeSupportLength
44285dfa 896 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 897 + fgkCarbonFiberTriangleLength
bf210566 898 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
899 localcoolingtubesupportrans[1] =
900 new TGeoTranslation(fgkCarbonFiberJunctionLength
901 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
902 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
903 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
904 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
905 - 0.5*(fgkCarbonFiberLowerSupportWidth
906 + fgkSSDSensorCenterSupportLength
907 - fgkSSDSensorCenterSupportThickness[0])
908 + 0.5*fgkSSDSensorLength,
909 - 0.5*fgkCoolingTubeSupportHeight);
910 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
911 localcoolingtubesupportrot[i] = new TGeoRotation();
912 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
913 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
914 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
915 localcoolingtubesupportmatrix[i] =
916 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
917 *localcoolingtubesupportrot[i]);
918 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
919 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
920 (*localcoolingtubesupportmatrix[0]));
921 /////////////////////////////////////////////////////////////
9b0c60ab 922 // End Ladder SSD Cooling Tube Support Transformations
923 /////////////////////////////////////////////////////////////
924 TGeoTranslation** localendladdercooltubetrans[2];
925 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
926 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
927 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
928 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
929 - (fgkCoolingTubeSupportLength
930 - fgkCoolingTubeSupportRmax),
931 fgkEndLadderMountingBlockPosition[0]
932 - fgkendladdercoolingsupportdistance[0]
933 + 0.5*fgkCoolingTubeSupportWidth,
934 - 0.5*fgkCoolingTubeSupportHeight);
935 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
936 - (fgkCoolingTubeSupportLength
937 - fgkCoolingTubeSupportRmax),
938 fgkEndLadderMountingBlockPosition[0]
939 + fgkendladdercoolingsupportdistance[1]
940 + 0.5*fgkCoolingTubeSupportWidth,
941 - 0.5*fgkCoolingTubeSupportHeight);
942 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
943 - fgkCoolingTubeSupportRmax)
944 + fgkCarbonFiberTriangleLength
945 - 2.0*fgkCarbonFiberJunctionLength,
946 0.0,
947 0.0);
948 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
949 fgkendladdercoolingsupportdistance[0]
950 + fgkendladdercoolingsupportdistance[1],
951 0.0);
952 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
953 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
954 + fgkCarbonFiberJunctionLength
955 - fgkCoolingTubeSupportLength,
956 fgkEndLadderCarbonFiberLowerJunctionLength[1]
957 - 0.5*fgkCoolingTubeSupportWidth
958 -fgkendladdercoolingsupportdistance[2],
959 - 0.5*fgkCoolingTubeSupportHeight);
960 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
961 + fgkCoolingTubeSupportLength
962 - fgkCoolingTubeSupportRmax
963 - fgkCarbonFiberJunctionLength,
964 fgkEndLadderCarbonFiberLowerJunctionLength[1]
965 - 0.5*fgkCoolingTubeSupportWidth
966 - fgkendladdercoolingsupportdistance[2],
967 - 0.5*fgkCoolingTubeSupportHeight);
968 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
969 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
970 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
971 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
972 (*localcoolingtubesupportrot[1]));
973 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
974 (*localcoolingtubesupportrot[1]));
975 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
976 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
977 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
978 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
979 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
980
981 fendladdercoolingtubesupportmatrix[1][0] =
982 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
983 *(*localcoolingtubesupportrot[1]));
984 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
985 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
986 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
987 /////////////////////////////////////////////////////////////
bf210566 988 // SSD Cooling Tube Transformations
989 /////////////////////////////////////////////////////////////
990 TGeoRotation* localcoolingtuberot = new TGeoRotation();
991 localcoolingtuberot->SetAngles(0.,90.,0.);
cd2243fb 992 TGeoTranslation* localcoolingtubetrans[2];
993 TVector3* localcoolingtubevect[2];
994
995 localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
bf210566 996 -fgkCarbonFiberTriangleLength),
cd2243fb 997 fgkCarbonFiberJunctionWidth // Y-coord is local Z, from sensor translation
998 - fgkCarbonFiberLowerSupportWidth
999 - fgkLowerSupportToSensorZ ,
bf210566 1000 - 0.5*fgkCoolingTubeSupportHeight);
cd2243fb 1001 localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
1002 localcoolingtubevect[0]->Y(),
1003 localcoolingtubevect[0]->Z());
78e34526 1004 for(Int_t j=0; j<2; j++){
1005 localcoolingtubetrans[j] =
1006 new TGeoTranslation(localcoolingtubevect[j]->X(),
1007 localcoolingtubevect[j]->Y(),
1008 localcoolingtubevect[j]->Z());
1009 fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j])
1010 *(*localcoolingtuberot));
1011 }
bf210566 1012 /////////////////////////////////////////////////////////////
9b0c60ab 1013 // SSD End Ladder Cooling Tube Transformations
1014 /////////////////////////////////////////////////////////////
1015 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1016 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1017 TGeoTranslation** localendlladdercoolingtubetrans[2];
cd2243fb 1018 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
1019 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
9b0c60ab 1020 for(Int_t i=0; i<2; i++)
cd2243fb 1021 for(Int_t j=0; j<2; j++)
9b0c60ab 1022 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
cd2243fb 1023
1024 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
9b0c60ab 1025 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1026 - fgkCoolingTubeSupportRmax)
1027 + fgkCarbonFiberJunctionLength,
cd2243fb 1028 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
9b0c60ab 1029 - 0.5*fgkCoolingTubeSupportHeight);
1030 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1031 - fgkCoolingTubeSupportRmax)
1032 - fgkCarbonFiberJunctionLength
1033 + fgkCarbonFiberTriangleLength,
cd2243fb 1034 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
9b0c60ab 1035 - 0.5*fgkCoolingTubeSupportHeight);
cd2243fb 1036
9b0c60ab 1037 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
cd2243fb 1038 - fgkCoolingTubeSupportRmax)
1039 + fgkCarbonFiberJunctionLength,
1040 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
9b0c60ab 1041 - 0.5*fgkCoolingTubeSupportHeight);
1042 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1043 - fgkCoolingTubeSupportRmax)
1044 - fgkCarbonFiberJunctionLength
1045 + fgkCarbonFiberTriangleLength,
cd2243fb 1046 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
9b0c60ab 1047 - 0.5*fgkCoolingTubeSupportHeight);
9b0c60ab 1048 for(Int_t i=0; i<2; i++)
cd2243fb 1049 for(Int_t j=0; j<2; j++){
9b0c60ab 1050 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1051 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1052 }
1053 /////////////////////////////////////////////////////////////
bf210566 1054 // SSD Hybrid Components Transformations
1055 /////////////////////////////////////////////////////////////
1056 const Int_t khybridmatrixnumber = 3;
1057 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1058 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1059 0.5*fgkSSDStiffenerWidth,
1060 0.5*fgkSSDStiffenerHeight);
1061 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1062 fgkSSDModuleStiffenerPosition[1],0.0);
1063
1064 localhybridtrans[2] = new TGeoTranslation(
1065 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1066 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1067 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1068 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1069 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1070 - fgkSSDSensorCenterSupportThickness[0]),
1071 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
ca86fdb4 1072 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
0fb26117 1073 - fgkSSDModuleVerticalDisalignment));
bf210566 1074 fhybridmatrix = new TGeoHMatrix();
1075 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1076 /////////////////////////////////////////////////////////////
1077 // SSD Cooling Block Transformations
1078 /////////////////////////////////////////////////////////////
78e34526 1079 TGeoTranslation localcoolingblocktrans (fcoolingtubematrix[0]->GetTranslation()[0]
1080 - 0.5*fgkSSDCoolingBlockLength,
1081 fhybridmatrix->GetTranslation()[1]-0.5*fgkSSDStiffenerWidth,
1082 fhybridmatrix->GetTranslation()[2]+0.5*fgkSSDStiffenerHeight+
1083 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1084 fcoolingblocksystematrix = new TGeoHMatrix(localcoolingblocktrans);
bf210566 1085 /////////////////////////////////////////////////////////////
1086 // SSD Stiffener Flex Transformations
1087 /////////////////////////////////////////////////////////////
1088 const Int_t klocalflexmatrixnumber = 4;
1089 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1090 for(Int_t i=0; i<fgkflexnumber; i++)
1091 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1092 for(Int_t i=0; i<fgkflexnumber; i++)
1093 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1094 localflexmatrix[i][j] = new TGeoCombiTrans();
1095 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1096 - 2.*fgkSSDModuleStiffenerPosition[1]
1097 - fgkSSDStiffenerWidth;
1098 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1099 +0.5*fgkSSDStiffenerLength,
1100 0.5*fgkSSDStiffenerWidth,
1101 -0.5*fgkSSDStiffenerHeight
1102 -0.5*fgkSSDFlexHeight[0]);
1103 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1104 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1105 -0.5*fgkSSDStiffenerWidth,
1106 -0.5*fgkSSDStiffenerHeight
1107 -0.5*fgkSSDFlexHeight[0]);
1108 TGeoRotation* localflexrot = new TGeoRotation();
1109 localflexrot->SetAngles(180.,0.,0.);
1110 localflexmatrix[1][0]->SetRotation(localflexrot);
1111 for(Int_t i=0; i<fgkflexnumber; i++)
1112 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1113 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1114 for(Int_t i=0; i<fgkflexnumber; i++){
1115 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1116 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1117 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1118 }
bf210566 1119 /////////////////////////////////////////////////////////////
1120 // SSD End Flex Transformations
1121 /////////////////////////////////////////////////////////////
1122 TGeoRotation* localendflexrot = new TGeoRotation();
1123 localendflexrot->SetAngles(0.0,90.0,0.0);
1124 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1125 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1126 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1127 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1128 * TMath::DegToRad()*ssdflexradiusmax
1129 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 1130 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1131 - 0.1*fgkSSDFlexFullLength;
bf210566 1132 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1133 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1134 + fgkSSDFlexLength[2];
1135 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1136 0.5*fgkSSDFlexWidth[0],
1137 2.*fgkSSDStiffenerHeight
1138 + 0.5*fgkSSDFlexHeight[0]);
1139 localendflexmatrix->SetRotation(localendflexrot);
1140 for(Int_t i=0; i<fgkflexnumber; i++)
1141 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1142 /////////////////////////////////////////////////////////////
1143 // End Ladder Carbon Fiber Junction
1144 /////////////////////////////////////////////////////////////
1145 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1146 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1147 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1148 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1149 localendladdercarbonfiberjunctionmatrix[i]
b28b5356 1150 = new TGeoCombiTrans*[fgkendladdercarbonfiberjunctionmatrixnumber];
bf210566 1151 localendladdercarbonfiberjunctionrot[i]
b28b5356 1152 = new TGeoRotation*[fgkendladdercarbonfiberjunctionmatrixnumber];
bf210566 1153 localendladdercarbonfiberjunctiontrans[i]
b28b5356 1154 = new TGeoTranslation*[fgkendladdercarbonfiberjunctionmatrixnumber];
bf210566 1155 fendladdercarbonfiberjunctionmatrix[i]
b28b5356 1156 = new TGeoHMatrix*[fgkendladdercarbonfiberjunctionmatrixnumber];
d7599219 1157 }
bf210566 1158 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
b28b5356 1159 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
bf210566 1160 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1161 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1162 }
1163 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
b28b5356 1164 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
bf210566 1165 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1166 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1167 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1168 0.0,0.0);
1169 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1170 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1171 * SinD(fgkCarbonFiberTriangleAngle),
1172 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1173 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1174 }
1175 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1176 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1177 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1178 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1179 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1180 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1181 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1182 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1183 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1184 localendladdercarbonfiberjunctionglobalmatrix[i] =
1185 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1186 *localendladdercarbonfiberjunctionglobalrot[i]);
1187 }
1188 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
b28b5356 1189 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
bf210566 1190 localendladdercarbonfiberjunctionmatrix[i][j] =
1191 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1192 *localendladdercarbonfiberjunctionrot[i][j]);
1193 fendladdercarbonfiberjunctionmatrix[i][j] =
1194 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1195 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1196 }
1197 /////////////////////////////////////////////////////////////
1198 // End Ladder Carbon Fiber Support
1199 /////////////////////////////////////////////////////////////
1200 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1201 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1202 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1203 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1204 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1205 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1206 }
1207 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1208 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1209 fendladdercarbonfibermatrix[i][j] =
1210 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1211 *(*fcarbonfibersupportmatrix[j]));
1212 /////////////////////////////////////////////////////////////
1213 // End Ladder SSD Mounting Block
1214 /////////////////////////////////////////////////////////////
1215 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1216 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1217 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1218 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1219 + fgkSSDMountingBlockLength[1])
1220 + 0.5*fgkCarbonFiberTriangleLength,
1221 fgkEndLadderMountingBlockPosition[i],
1222 - fgkSSDMountingBlockHeight[1]
1223 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1224 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1225 endladdermountingblockrot->SetAngles(0.,90.,0.);
1226 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1227 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1228 /////////////////////////////////////////////////////////////
1229 // End Ladder SSD Mounting Block Clip Matrix
1230 /////////////////////////////////////////////////////////////
1231 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1232 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1233
1234 TGeoRotation* localendladdercliprot = new TGeoRotation();
1235 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1236 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1237 - fgkSSDMountingBlockLength[1])
1238 + fgkSSDMountingBlockLength[0],0.,0.);
1239 localendladdercliprot->SetAngles(90.,180.,-90.);
1240 TGeoCombiTrans* localendladderclipcombitrans =
1241 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1242 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1243 for(Int_t j=0; j<2; j++){
1244 fendladdermountingblockclipmatrix[i][j] =
1245 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1246 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1247 }
bf210566 1248 /////////////////////////////////////////////////////////////
1249 // End Ladder Carbon Fiber Lower Support
1250 /////////////////////////////////////////////////////////////
1251 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1252 fendladderlowersupptrans[i] =
1253 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1254 + 0.5*fgkSSDMountingBlockWidth),
1255 - 0.5*fgkCarbonFiberLowerSupportHeight);
5d9d4033 1256 fendladderlowersupptrans[0]->SetDz(-0.5*fgkCarbonFiberLowerSupportHeight-fgkSSDTolerance);
bf210566 1257 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1258 fgkCarbonFiberLowerSupportVolumePosition[1]
1259 + fgkCarbonFiberLowerSupportVolumePosition[0],
1260 0.0);
1261 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1262 /////////////////////////////////////////////////////////////
1263 // Matrix for positioning Ladder into mother volume
1264 /////////////////////////////////////////////////////////////
1265 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1266 for(Int_t i=0; i<fgkladdernumber; i++)
1267 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1268 TGeoRotation* localladdermotherrot = new TGeoRotation();
1269 localladdermotherrot->SetAngles(0.,90.,0.);
1270 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1271 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1272 for(Int_t i=0; i<fgkladdernumber; i++){
1273 localladdermothertrans[i] = new TGeoTranslation(0.,
1274 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1275 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1276 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1277 * fgkCarbonFiberJunctionWidth,0.);
1278 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1279 *localladdermotherrot);
1280 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1281 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1282 }
44285dfa 1283 /////////////////////////////////////////////////////////////
bf210566 1284 // Ladder Cables Matrices
44285dfa 1285 /////////////////////////////////////////////////////////////
44285dfa 1286 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1287 + fgkSSDFlexHeight[1];
44285dfa 1288 Double_t ssdladdercabletransx[3];
1289 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1290 * SinD(2.*fgkSSDFlexAngle)
1291 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1292 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1293 - ssdladdercabletransx[0]
bf210566 1294 / SinD(2.*fgkSSDFlexAngle))
1295 * CosD(fgkSSDFlexAngle);
44285dfa 1296 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1297 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1298 - fgkSSDFlexLength[2]-TMath::Pi()
1299 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1300 - fgkSSDLadderCableWidth)
bf210566 1301 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1302 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1303 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1304 ssdladdercabletransx[1]
bf210566 1305 * TanD(fgkSSDFlexAngle),
44285dfa 1306 ssdladdercabletransx[2]
bf210566 1307 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1308 TGeoRotation* localladdercablerot[3];
bf210566 1309 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1310 localladdercablerot[0]->SetAngles(90.,0.,0.);
1311 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1312 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1313 * (*localladdercablerot[0]));
cd2243fb 1314 //TGeoRotation* localladdercablerot = new TGeoRotation();
1315 //localladdercablerot->SetAngles(90.,0.,0.);
44285dfa 1316 ////////////////////////////////////////////
1317 // LocalLadderCableCombiTransMatrix
1318 ////////////////////////////////////////////
1319 const Int_t klocalladdersidecablesnumber = 2;
1320 const Int_t klocalladdercombitransnumber = 5;
1321 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1322 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1323 localladdercablecombitransmatrix[i] =
1324 new TGeoCombiTrans*[klocalladdercombitransnumber];
1325 ///////////////////////////////////////////
1326 // Left Side Ladder Cables Transformations
1327 ///////////////////////////////////////////
1328 localladdercablecombitransmatrix[0][0] =
d7599219 1329 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1330 0.,0.,NULL);
bf210566 1331 localladdercablecombitransmatrix[0][1] =
1332 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1333 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1334 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1335 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1336 - 0.5*(fgkCarbonFiberLowerSupportWidth
1337 + fgkSSDSensorCenterSupportLength
1338 - fgkSSDSensorCenterSupportThickness[0]),
1339 - (fgkSSDModuleCoolingBlockToSensor
1340 + 0.5*fgkCoolingTubeSupportHeight
1341 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1342 - fgkSSDChipHeight),NULL);
44285dfa 1343 localladdercablecombitransmatrix[0][2] =
d7599219 1344 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1345 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1346 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1347 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1348 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1349 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1350 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1351 new TGeoRotation("",180.,0.,0.));
44285dfa 1352 localladdercablecombitransmatrix[0][4] =
1353 new TGeoCombiTrans(-ssdladdercabletransx[0]
1354 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1355 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1356 0.,
1357 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1358 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1359 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1360 + ssdladdercabletransz[2],localladdercablerot[2]);
1361 ///////////////////////////////////////////
1362 // Rigth Side Ladder Cables Transformations
1363 ///////////////////////////////////////////
bf210566 1364 TGeoCombiTrans* localladdercablessdmodulematrix =
1365 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1366 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1367 fgkSSDStiffenerWidth,
1368 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1369 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1370 localladdercablecombitransmatrix[1][i] =
bf210566 1371 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1372 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1373 ///////////////////////////////////////////
bf210566 1374 // Setting LadderCableHMatrix
44285dfa 1375 ///////////////////////////////////////////
bf210566 1376 Int_t beamaxistrans[2][3];
1377 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1378 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1379 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1380 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1381 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1382 beamaxistrans[1][2] = beamaxistrans[1][0];
1383 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1384 TGeoRotation* laddercablerot = new TGeoRotation();
1385 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1386 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1387 Double_t* laddercabletransvector;
1388 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1389 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1390 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1391 }
1392 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1393 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1394 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1395 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1396 localladdercablehmatrix[i][j]->MultiplyLeft(
1397 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1398 }
1399 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1400 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1401 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1402 laddercabletransvector[1]
bf210566 1403 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1404 * fgkCarbonFiberJunctionWidth,
bf210566 1405 laddercabletransvector[2]);
1406 laddercablecombitrans->SetRotation(*laddercablerot);
1407 laddercablecombitrans->SetTranslation(*laddercabletrans);
1408 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1409 }
1410 fladdercablematrix[i][2] =
1411 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1412 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1413 fladdercablematrix[i][3] =
1414 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1415 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1416 }
1417 for(Int_t i=0; i<fgkladdercablesnumber; i++)
78e34526 1418 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1419 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1420
bf210566 1421 ///////////////////////////////////////////
1422 // Setting Ladder HMatrix
1423 ///////////////////////////////////////////
1424 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1425 fgkSSDLay6SensorsNumber};
1426 for(Int_t i=0; i<fgkladdernumber; i++){
1427 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1428 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1429 fladdermatrix[i][j] = new TGeoHMatrix();
1430 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1431 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1432 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1433 }
1434 }
1435 ///////////////////////////////////////////
1436 // Setting SSD Sensor Matrix
1437 ///////////////////////////////////////////
1438 TGeoCombiTrans* localssdsensorcombitrans[2];
1439 TGeoRotation* localssdsensorrot = new TGeoRotation();
1440 localssdsensorrot->SetAngles(0.,90.,0.);
1441 TGeoTranslation* localssdsensortrans[2];
1442 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1443 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1444 fgkCarbonFiberJunctionWidth
1445 - fgkCarbonFiberLowerSupportWidth
1446 - fgkLowerSupportToSensorZ,
bf210566 1447 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1448 - fgkSSDModuleCoolingBlockToSensor
e21cdd03 1449 + (fgkSSDSensorSideSupportHeight[1]
0fb26117 1450 - fgkSSDSensorSideSupportHeight[0]));
bf210566 1451 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1452 fgkCarbonFiberJunctionWidth
1453 - fgkCarbonFiberLowerSupportWidth
1454 - fgkLowerSupportToSensorZ,
bf210566 1455 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1456 -fgkSSDModuleCoolingBlockToSensor);
cd2243fb 1457
bf210566 1458 for(Int_t i=0; i<2; i++)
1459 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1460 *localssdsensorrot);
1461 for(Int_t i=0; i<fgkladdernumber; i++){
1462 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1463 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1464 switch(i){
1465 case 0: //Ladder of Layer5
1466 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1467 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1468 *localssdsensorcombitrans[1])));
1469 break;
1470 case 1: //Ladder of Layer6
1471 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1472 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1473 *localssdsensorcombitrans[0])));
1474 break;
1475 }
1476 }
1477 }
1478 //////////////////////////
1479 // Setting SSD End Ladder
1480 //////////////////////////
1481 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1482 for(Int_t i=0; i<2; i++){
1483 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1484 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1485 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1486 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1487 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1488 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1489 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1490 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1491 }
1492 /////////////////////////////////////////////////////
1493 // Setting the CombiTransformation to pass ITS center
1494 /////////////////////////////////////////////////////
1495 Double_t itscentertransz[fgklayernumber];
1496 itscentertransz[0] = fgkSSDLay5LadderLength
1497 - fgkLay5CenterITSPosition;
1498 itscentertransz[1] = fgkSSDLay6LadderLength
1499 - fgkLay6CenterITSPosition;
1500 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1501 + 0.5*fgkCoolingTubeSupportHeight;
1502 TGeoRotation* itscenterrot[3];
1503 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1504 itscenterrot[0]->SetAngles(90.,180.,-90.);
1505 itscenterrot[1]->SetAngles(0.,90.,0.);
1506 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1507 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1508 for(Int_t i=0; i<fgklayernumber; i++)
1509 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1510 itssensortransy,
1511 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1512 - itscentertransz[i],itscenterrot[2]);
1513 TGeoRotation** locallayerrot[fgklayernumber];
1514 TGeoTranslation** locallayertrans[fgklayernumber];
1515 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1516 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1517 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1518 - fgkLay5CenterITSPosition);
1519 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1520 - fgkLay6CenterITSPosition);
1521 const Int_t kssdlayladdernumber[fgklayernumber] =
1522 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1523 for(Int_t i=0; i<fgklayernumber; i++){
1524 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1525 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1526 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1527 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1528 }
1529 Double_t layerladderangleposition[fgklayernumber] =
1530 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1531 Double_t layerradius = 0.;
1532 for(Int_t i=0; i<fgklayernumber; i++){
1533 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1534 switch(i){
1535 case 0: //Ladder of Layer5
1536 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1537 break;
1538 case 1: //Ladder of Layer6
1539 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1540 break;
1541 }
1542 locallayerrot[i][j] = new TGeoRotation();
1543 locallayertrans[i][j] = new TGeoTranslation();
1544 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1545 locallayertrans[i][j]->SetTranslation(layerradius
1546 * CosD(90.0+j*layerladderangleposition[i]),
1547 layerradius
1548 * SinD(90.0+j*layerladderangleposition[i]),0.);
1549 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1550 *locallayerrot[i][j]);
1551 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1552 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1553 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1554 }
1555 }
44285dfa 1556 /////////////////////////////////////////////////////////////
bf210566 1557 // Deallocating memory
44285dfa 1558 /////////////////////////////////////////////////////////////
bf210566 1559 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1560 delete carbonfiberot[i];
1561 delete localcarbonfibersupportmatrix[i];
1562 }
1563 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1564 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1565 delete localcarbonfiberjunctionmatrix[i][j];
1566 delete localcarbonfiberjunctionrot[i][j];
1567 delete localcarbonfiberjunctiontrans[i][j];
1568 }
1569 delete [] localcarbonfiberjunctionmatrix[i];
1570 delete [] localcarbonfiberjunctionrot[i];
1571 delete [] localcarbonfiberjunctiontrans[i];
1572 }
1573 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1574 delete localcarbonfiberlowersupportrans[i];
1575 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1576 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1577 delete localssdsensorsupportmatrix[i][j];
1578 delete localssdsensorsupportrot[i][j];
1579 delete localssdsensorsupportrans[i][j];
1580 }
1581 delete [] localssdsensorsupportmatrix[i];
1582 delete [] localssdsensorsupportrot[i];
1583 delete [] localssdsensorsupportrans[i];
1584 }
1585 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1586 delete localcoolingtubesupportmatrix[i];
1587 delete localcoolingtubesupportrot[i];
1588 delete localcoolingtubesupportrans[i];
1589 }
cd2243fb 1590 for(Int_t j=0; j<2; j++){
1591 delete localcoolingtubevect[j];
1592 delete localcoolingtubetrans[j];
bf210566 1593 }
9b0c60ab 1594 delete endladdermountingblockrot;
bf210566 1595 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
bf210566 1596 for(Int_t i=0; i<fgkflexnumber; i++){
1597 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1598 delete localflexmatrix[i][j];
1599 delete [] localflexmatrix[i];
1600 }
9b0c60ab 1601 delete localendlladdercoolingtuberot;
1602 for(Int_t i=0; i<2; i++){
cd2243fb 1603 for(Int_t j=0; j<2; j++)
1604 delete localendlladdercoolingtubetrans[i][j];
9b0c60ab 1605 delete [] localendlladdercoolingtubetrans[i];
1606 }
1607
bf210566 1608 delete localflexrot;
1609 delete localendflexrot;
1610 delete localendflexmatrix;
1611 for(Int_t i=0; i<fgkladdernumber; i++){
1612 delete localladdermothertrans[i];
1613 delete localladdermothercombitrans[i];
1614 }
1615 delete localladdermotherrot;
1616 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
b28b5356 1617 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
bf210566 1618 delete localendladdercarbonfiberjunctionmatrix[i][j];
1619 delete localendladdercarbonfiberjunctionrot[i][j];
1620 delete localendladdercarbonfiberjunctiontrans[i][j];
1621 }
1622 delete [] localendladdercarbonfiberjunctionmatrix[i];
1623 delete [] localendladdercarbonfiberjunctionrot[i];
1624 delete [] localendladdercarbonfiberjunctiontrans[i];
1625 delete localendladdercarbonfiberjunctionglobalrot[i];
1626 delete localendladdercarbonfiberjunctionglobaltrans[i];
1627 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1628 }
9b0c60ab 1629 for(Int_t i=0; i<2; i++){
1630 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1631 delete [] localendladdercooltubetrans[i];
1632 }
1633 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1634 delete localendladdercarbonfibertrans[i];
1635 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1636 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1637 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1638 delete localladdercablecombitransmatrix[i][j];
1639 delete []localladdercablecombitransmatrix[i];
1640 }
9b0c60ab 1641 delete localendladdercliprot;
1642 delete localendladdercliptrans;
bf210566 1643 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1644 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1645 delete localladdercablehmatrix[i][j];
1646 delete []localladdercablehmatrix[i];
1647 }
1648 delete laddercablerot;
1649 delete laddercabletrans;
1650 delete laddercablecombitrans;
1651 delete localladdercablessdmodulematrix;
1652 delete localssdsensorrot;
1653 for(Int_t i=0; i<2; i++){
1654 delete localssdsensortrans[i];
1655 delete localssdsensorcombitrans[i];
1656 }
1657 for(Int_t i=0; i<fgklayernumber; i++){
1658 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1659 delete locallayerrot[i][j];
1660 delete locallayertrans[i][j];
1661 delete locallayercombitrans[i][j];
1662 }
1663 delete [] locallayerrot[i];
1664 delete [] locallayertrans[i];
1665 delete [] locallayercombitrans[i];
1666 delete localbeamaxistrans[i];
1667 }
1668 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1669 for(Int_t i=0; i<fgkladdernumber; i++){
1670 for(Int_t j=0; j<fgkladdernumber; j++)
1671 delete ladderglobalmatrix[i][j];
1672 delete [] ladderglobalmatrix[i];
1673 }
1674 /////////////////////////////////////////////////////////////
1675 fTransformationMatrices = kTRUE;
d7599219 1676}
bf210566 1677///////////////////////////////////////////////////////////////////////////////
1678void AliITSv11GeometrySSD::CreateBasicObjects(){
1679 /////////////////////////////////////////////////////////////
1680 // Method generating the Objects of SSD Geometry
1681 /////////////////////////////////////////////////////////////
1682 // SSD Sensor
1683 ///////////////////////////////////
1684 SetSSDSensor();
1685 /////////////////////////////////////////////////////////////
1686 // Carbon Fiber Support
1687 /////////////////////////////////////////////////////////////
1688 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1689 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1690 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1691 /////////////////////////////////////////////////////////////
bf210566 1692 // Carbon Fiber Junction
44285dfa 1693 /////////////////////////////////////////////////////////////
ca86fdb4 1694 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
bf210566 1695 /////////////////////////////////////////////////////////////
1696 // Carbon Fiber Lower Support
1697 /////////////////////////////////////////////////////////////
1698 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1699 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1700 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1701 /////////////////////////////
1702 // SSD Sensor Support
1703 /////////////////////////////
1704 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1705 new TGeoVolume*[fgkssdsensorsupportnumber];
44285dfa 1706 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
bf210566 1707 fgkSSDSensorSideSupportThickness[1]};
1708 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1709 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1710 fgkSSDSensorSideSupportHeight[i],
1711 fgkSSDSensorSideSupportWidth,
1712 sidesupporthickness);
1713 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1714 fgkSSDSensorCenterSupportHeight[i],
1715 fgkSSDSensorCenterSupportWidth,
1716 sidesupporthickness);
1717 }
1718 /////////////////////////////////////////////////////////////
1719 // SSD Cooling Tube Support
1720 /////////////////////////////////////////////////////////////
3c057f23 1721 Int_t edgesnumber = 3;
bf210566 1722 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1723 /////////////////////////////////////////////////////////////
1724 // SSD Hybrid
1725 /////////////////////////////////////////////////////////////
1726 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1727 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1728 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1729 /////////////////////////////////////////////////////////////
1730 // SSD Cooling Block System
1731 /////////////////////////////////////////////////////////////
1732 fssdcoolingblocksystem = GetCoolingBlockSystem();
1733 /////////////////////////////////////////////////////////////
1734 // SSD Cooling Tube
1735 /////////////////////////////////////////////////////////////
cd2243fb 1736 CreateCoolingTubes();
bf210566 1737 /////////////////////////////////////////////////////////////
1738 // SSD Flex
1739 /////////////////////////////////////////////////////////////
1740 fssdstiffenerflex = GetSSDStiffenerFlex();
1741 fssdendflex = GetSSDEndFlex();
1742 ///////////////////////////////////
1743 // End Ladder Carbon Fiber Junction
1744 ///////////////////////////////////
1745 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1746 fendladdercarbonfiberjunction[i] =
1747 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1748 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1749 fendladdercarbonfiberjunction[i][0] =
ca86fdb4 1750 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
bf210566 1751 fendladdercarbonfiberjunction[i][1] =
ca86fdb4 1752 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
bf210566 1753 }
1754 ///////////////////////////////////
1755 // End Ladder Mounting Block
1756 ///////////////////////////////////
1757 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1758 ///////////////////////////////////
1759 // End Ladder Mounting Block
1760 ///////////////////////////////////
1761 fendladdermountingblockclip = GetMountingBlockClip();
1762 ///////////////////////////////////
1763 // Ladder Support
1764 ///////////////////////////////////
1765 TList* laddersupportlist = GetMountingBlockSupport(20);
1766 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1767 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1768 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1769 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
bf210566 1770 /////////////////////////////////////////////////////////////
1771 // Deallocating memory
44285dfa 1772 /////////////////////////////////////////////////////////////
bf210566 1773 delete carbonfibersupportlist;
1774 delete carbonfiberlowersupportlist;
1775 delete ssdhybridcomponentslist;
9b0c60ab 1776 delete laddersupportlist;
44285dfa 1777 /////////////////////////////////////////////////////////////
bf210566 1778 fBasicObjects = kTRUE;
1779}
1780/////////////////////////////////////////////////////////////////////////////////
1781void AliITSv11GeometrySSD::SetSSDSensor(){
1782 ////////////////////////////////////////////////////////////////
1783 // Method generating SSD Sensors: it sets the private variables
1784 // fSSDSensor5, fSSDSensor6
1785 ////////////////////////////////////////////////////////////////
44285dfa 1786 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1787 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1788 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
44285dfa 1789 0.5*ssdsensitivewidth,
bf210566 1790 0.5*fgkSSDSensorHeight,
1791 0.5*ssdsensitivelength);
1792 TGeoVolume* ssdsensorsensitiveLay5 =
f510fd70 1793 new TGeoVolume(fgkSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1794 TGeoVolume* ssdsensorsensitiveLay6 =
f510fd70 1795 new TGeoVolume(fgkSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1796 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1797 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
44285dfa 1798 TGeoBBox* ssdsensorinsensitiveshape[2];
1799 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1800 0.5*fgkSSDSensorInsensitiveWidth,
bf210566 1801 0.5*fgkSSDSensorHeight,
1802 0.5*fgkSSDSensorLength);
44285dfa 1803 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
44285dfa 1804 0.5*ssdsensitivewidth,
bf210566 1805 0.5*fgkSSDSensorHeight,
1806 0.5*fgkSSDSensorInsensitiveWidth);
44285dfa 1807 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1808 "SSDSensorInsensitive2"};
44285dfa 1809 TGeoVolume* ssdsensorinsensitive[2];
1810 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1811 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1812 fSSDSensorMedium);
1813 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1814 }
bf210566 1815 /////////////////////////////////////////////////////////////
1816 // Virtual Volume containing SSD Sensor
1817 /////////////////////////////////////////////////////////////
1818 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1819 0.5*fgkSSDSensorWidth,
1820 0.5*fgkSSDSensorHeight,
1821 0.5*fgkSSDSensorLength);
ef9451a3 1822 fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
bf210566 1823 fSSDAir);
ef9451a3 1824 fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
bf210566 1825 fSSDAir);
1826 /////////////////////////////////////////////////////////////
1827 for(Int_t i=0; i<4; i++){
1828 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1829 ssdsensorinsensitive[1],i<2?1:2,
1830 new TGeoTranslation(
1831 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1832 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1833 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1834 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1835 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
44285dfa 1836 ssdsensorinsensitive[1],i<2?1:2,
bf210566 1837 new TGeoTranslation(
1838 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1839 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1840 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1841 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1842 }
1843 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1844 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1845}
bf210566 1846///////////////////////////////////////////////////////////////////////////////
1847TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1848 /////////////////////////////////////////////////////////////
1849 // Method generating the Carbon Fiber Support
1850 /////////////////////////////////////////////////////////////
1851 const Int_t kvertexnumber = 4;
1852 const Int_t kshapesnumber = 2;
1853 TVector3** vertexposition[kshapesnumber];
1854 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1855 Double_t carbonfibersupportxaxisEdgeproj =
1856 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1857 * TMath::DegToRad());
1858 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1859 / fgkCarbonFiberSupportXAxisLength);
1860 /////////////////////
1861 //Vertex Positioning
1862 ////////////////////
1863 vertexposition[0][0] = new TVector3();
1864 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1865 fgkCarbonFiberSupportYAxisLength);
1866 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1867 carbonfibersupportxaxisEdgeproj
1868 * TMath::Tan(theta));
1869 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1870 - carbonfibersupportxaxisEdgeproj,
1871 fgkCarbonFiberSupportYAxisLength
1872 - vertexposition[0][2]->Y());
1873 ////////////////////////////////////////////////////
1874 //Setting the parameters for Isometry Transformation
1875 ////////////////////////////////////////////////////
1876 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1877 + fgkCarbonFiberSupportTopEdgeDist[0]
1878 + fgkCarbonFiberSupportWidth);
1879 Double_t* param = new Double_t[4];
1880 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1881 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
160835d5 1882 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1883 (GetReflection(vertexposition[0][j],param))->Y());
a6e0ebfe 1884 const char* carbonfibersupportshapename[kshapesnumber] =
bf210566 1885 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
a6e0ebfe 1886 const char* carbonfibersupportname[kshapesnumber] =
bf210566 1887 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1888 TGeoArb8* carbonfibersupportshape[kshapesnumber];
1889 TGeoVolume* carbonfibersupport[kshapesnumber];
1890 TList* carbonfibersupportlist = new TList();
1891 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1892 Double_t carbonfibersupportheight =
1893 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1894 *TMath::DegToRad());
1895 for(Int_t i = 0; i< kshapesnumber; i++){
1896 carbonfibersupportshape[i] =
1897 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1898 carbonfibersupportshapename[i],i==0 ? 1: -1);
1899 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1900 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1901 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1902 carbonfibersupportlist->Add(carbonfibersupport[i]);
1903 }
1904 /////////////////////////////////////////////////////////////
1905 // Deallocating memory
1906 /////////////////////////////////////////////////////////////
1907 for(Int_t i=0; i< kshapesnumber; i++){
1908 for(Int_t j=0; j< kvertexnumber; j++)
1909 delete vertexposition[i][j];
1910 delete [] vertexposition[i];
1911 }
1912 delete [] param;
44285dfa 1913 /////////////////////////////////////////////////////////////
bf210566 1914 return carbonfibersupportlist;
d7599219 1915}
1916/////////////////////////////////////////////////////////////////////////////////
bf210566 1917TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 1918 /////////////////////////////////////////////////////////////
bf210566 1919 // Method generating SSD Carbon Fiber Junction
44285dfa 1920 /////////////////////////////////////////////////////////////
bf210566 1921 const Int_t kvertexnumber = 6;
1922 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
d4ff3e0a 1923 Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1924 * TMath::DegToRad()),-1.,0.,0.};
bf210566 1925 TVector3* vertex[kvertexnumber];
1926 vertex[0] = new TVector3();
1927 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
1928 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1929 * TMath::DegToRad()),
1930 fgkCarbonFiberJunctionEdge[0]
1931 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
1932 * TMath::DegToRad()));
5d9d4033 1933 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance,
bf210566 1934 fgkCarbonFiberJunctionEdge[1]);
5d9d4033 1935 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance);
bf210566 1936 vertex[1] = GetReflection(vertex[5],reflectionparam);
1937 vertex[2] = GetReflection(vertex[4],reflectionparam);
1938 Double_t xvertexpoints[6], yvertexpoints[6];
1939 for(Int_t i=0; i<kvertexnumber; i++)
1940 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
1941 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
1942 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
1943 carbonfiberjunctionshape->DefineSection(1,0.5*width);
1944 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
1945 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
1946 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
1947 /////////////////////////////////////////////////////////////
1948 // Deallocating memory
1949 /////////////////////////////////////////////////////////////
1950 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
1951 /////////////////////////////////////////////////////////////
1952 return carbonfiberjunction;
1953}
1954////////////////////////////////////////////////////////////////////////////////
1955TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
1956 /////////////////////////////////////////////////////////////
1957 // Method generating the Carbon Fiber Lower Support
1958 /////////////////////////////////////////////////////////////
1959 const Int_t kvertexnumber = 4;
1960 const Int_t kshapesnumber = 2;
1961 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
1962 fgkCarbonFiberLowerSupportWidth};
1963 TVector3** vertexposition[kshapesnumber];
1964 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
1965 new TVector3*[kvertexnumber];
1966 //First Shape Vertex Positioning
1967 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
1968 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
1969 - fgkCarbonFiberLowerSupportLowerLenght);
1970 vertexposition[0][2] = new TVector3();
1971 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
1972 //Second Shape Vertex Positioning
1973 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
1974 - fgkCarbonFiberLowerSupportVolumePosition[0])
1975 / fgkCarbonFiberTriangleLength);
1976 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
1977 vertexposition[0][0]->X()*TMath::Tan(theta)
1978 + fgkCarbonFiberLowerSupportVolumePosition[0]);
1979 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
1980 vertexposition[0][1]->X()*TMath::Tan(theta)
1981 + fgkCarbonFiberLowerSupportVolumePosition[0]);
1982 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
1983 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
1984 fgkCarbonFiberLowerSupportVolumePosition[1]);
a6e0ebfe 1985 const char* carbonfiberlowersupportshapename[kshapesnumber] =
bf210566 1986 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
a6e0ebfe 1987 const char* carbonfiberlowersupportname[kshapesnumber] =
bf210566 1988 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
1989 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
1990 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
1991 TList* carbonfiberlowersupportlist = new TList();
1992 for(Int_t i = 0; i< kshapesnumber; i++){
1993 carbonfiberlowersupportshape[i] =
1994 GetArbShape(vertexposition[i],width,
1995 fgkCarbonFiberLowerSupportHeight,
1996 carbonfiberlowersupportshapename[i]);
1997 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
1998 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
1999 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2000 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2001 }
2002 /////////////////////////////////////////////////////////////
2003 // Deallocating memory
2004 /////////////////////////////////////////////////////////////
2005 for(Int_t i=0; i< kshapesnumber; i++){
2006 for(Int_t j=0; j< kvertexnumber; j++)
2007 delete vertexposition[i][j];
2008 delete [] vertexposition[i];
2009 }
2010 /////////////////////////////////////////////////////////////
2011 return carbonfiberlowersupportlist;
2012}
2013///////////////////////////////////////////////////////////////////////////////
2014TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
5cb5bc3d 2015 Double_t width, const Double_t* thickness)const{
bf210566 2016 /////////////////////////////////////////////////////////////
2017 // Method generating the Sensor Support
2018 /////////////////////////////////////////////////////////////
2019 const Int_t kvertexnumber = 6;
2020 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2021 TVector3* vertexposition[kvertexnumber];
2022 vertexposition[0] = new TVector3();
2023 vertexposition[1] = new TVector3(0.0,length);
2024 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2025 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2026 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2027 vertexposition[5] = new TVector3(vertexposition[4]->X());
2028 Double_t xvertexpoints[6], yvertexpoints[6];
2029 for(Int_t i=0; i<kvertexnumber; i++)
2030 xvertexpoints[i] = vertexposition[i]->X(),
2031 yvertexpoints[i] = vertexposition[i]->Y();
2032 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2033 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2034 ssdsensorsupportshape->DefineSection(1,0.5*width);
2035 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2036 ssdsensorsupportshape,fSSDSensorSupportMedium);
2037 /////////////////////////////////////////////////////////////
2038 // Deallocating memory
2039 /////////////////////////////////////////////////////////////
2040 for (Int_t i=0; i<kvertexnumber; i++)
2041 delete vertexposition[i];
2042 /////////////////////////////////////////////////////////////
2043 return ssdsensorsupport;
2044}
2045////////////////////////////////////////////////////////////////////////////////
2046TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2047 /////////////////////////////////////////////////////////////
2048 // Method generating the Cooling Tube Support
2049 /////////////////////////////////////////////////////////////
2050 if(nedges%2!=0) nedges--;
2051 const Int_t kvertexnumber = nedges+5;
2052 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2053 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2054 Double_t angle = 90.+phi;
2055 Double_t psi = 90.-phi;
2056 ///////////////////////////////////////
2057 // Vertex Positioning for TGeoXTru
2058 ///////////////////////////////////////
2059 TVector3** vertexposition = new TVector3*[kvertexnumber];
cd2243fb 2060
f510fd70 2061 Double_t router = fgkCoolingTubeSupportRmin/CosD(phi/nedges); // Recalc inner radius so that tube fits inside
2062 vertexposition[0] = new TVector3(router*CosD(angle),
2063 router*SinD(angle));
bf210566 2064 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2065 fgkCoolingTubeSupportRmax*SinD(angle));
2066 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2067 fgkCoolingTubeSupportRmax);
2068 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2069 fgkCoolingTubeSupportRmax);
2070 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2071 vertexposition[1]->Y());
cd2243fb 2072
bf210566 2073 for(Int_t i=0; i<nedges; i++)
2074 vertexposition[i+5] =
f510fd70 2075 new TVector3(router*CosD(psi+i*(2.*phi/nedges)),
2076 router*SinD(psi+i*(2.*phi/nedges)));
bf210566 2077 ///////////////////////////////////////////////////////////////////////
2078 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2079 ///////////////////////////////////////////////////////////////////////
2080 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2081 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2082 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2083 for(Int_t i=0; i<kvertexnumber; i++){
2084 xvertexpoints[i] = vertexposition[i]->X();
2085 yvertexpoints[i] = vertexposition[i]->Y();
2086 }
2087 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2088 yvertexpoints);
2089 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2090 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2091 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2092 coolingtubesupportarcshape,
2093 fSSDTubeHolderMedium);
2094 coolingtubesupportarc->SetLineColor(fColorG10);
2095 //////////////////////////////////////////////////////////////////////////
2096 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2097 //////////////////////////////////////////////////////////////////////////
2098 TGeoTubeSeg* coolingtubesupportsegshape =
2099 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2100 fgkCoolingTubeSupportRmax,
2101 0.5*fgkCoolingTubeSupportWidth,
2102 phi,360-phi);
2103 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2104 coolingtubesupportsegshape,
2105 fSSDTubeHolderMedium);
2106 coolingtubesupportseg->SetLineColor(fColorG10);
2107 //////////////////////////////////////////////////////////////////////////
2108 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2109 //////////////////////////////////////////////////////////////////////////
2110 Double_t* boxorigin = new Double_t[3];
2111 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2112 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2113 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2114 0.5*fgkCoolingTubeSupportHeight,
2115 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2116 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2117 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2118 coolingtubesupportbox->SetLineColor(fColorG10);
2119 //////////////////////////////////////////////////////////////////////////
2120 // Cooling Tube for Cooling Tube Support
2121 //////////////////////////////////////////////////////////////////////////
2122 TGeoXtru* coolingtubearcshape[2];
2123 coolingtubearcshape[0] = new TGeoXtru(2);
2124 Double_t* xvert = new Double_t[nedges+2];
2125 Double_t* yvert = new Double_t[nedges+2];
2126 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2127 ////////////////////////////////////////
2128 // Positioning the vertices for TGeoXTru
2129 ////////////////////////////////////////
2130 xvert[0] = 0., yvert[0] = 0.;
2131 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2132 for(Int_t i=0; i< nedges; i++)
2133 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2134 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2135 ////////////////////////////////////////
2136 // Defining TGeoXTru PolyGone
2137 ////////////////////////////////////////
2138 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2139 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2140 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2141 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2142 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2143 TGeoVolume* coolingtubearc[2];
2144 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2145 coolingtubearcshape[0],fSSDCoolingTubeWater);
2146 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2147 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2148 coolingtubearc[0]->SetLineColor(fColorWater);
2149 coolingtubearc[1]->SetLineColor(fColorPhynox);
2150 ////////////////////////////////////////////
2151 // Defining TGeoTubeSeg Part of Cooling Tube
2152 ////////////////////////////////////////////
2153 TGeoTubeSeg* coolingtubesegshape[2];
2154 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2155 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2156 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2157 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2158 TGeoVolume* coolingtubeseg[2];
2159 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2160 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2161 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2162 coolingtubesegshape[1],fSSDCoolingTubeWater);
2163 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2164 coolingtubeseg[1]->SetLineColor(fColorWater);
2165 /////////////////////////////////////////////////////////////
2166 // Virtual Volume containing Cooling Tube Support
2167 /////////////////////////////////////////////////////////////
2168 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2169 const Int_t kvirtualvertexnumber = 8;
2170 TVector3* virtualvertex[kvirtualvertexnumber];
2171 ////////////////////////////////////////
2172 // Positioning the vertices for TGeoXTru
2173 ////////////////////////////////////////
2174 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2175 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2176 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2177 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2178 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2179 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2180 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2181 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2182 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2183 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2184 xmothervertex[i] = virtualvertex[i]->X(),
2185 ymothervertex[i] = virtualvertex[i]->Y();
2186 ////////////////////////////////////////
2187 // Defining TGeoXTru PolyGone
2188 ////////////////////////////////////////
2189 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2190 ymothervertex);
2191 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2192 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
cd2243fb 2193 /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2194 virtualCoolingTubeSupportShape,fSSDAir); */
2195 TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
2196
bf210566 2197 ////////////////////////////////////////
2198 // Positioning Volumes in Virtual Volume
2199 ////////////////////////////////////////
2200 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2201 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2202 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2203 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2204 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
cd2243fb 2205 //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2206 //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2207 //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2208 //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
bf210566 2209 /////////////////////////////////////////////////////////////
2210 // Deallocating memory
2211 /////////////////////////////////////////////////////////////
2212 delete [] vertexposition;
3e008bd7 2213 delete [] xvertexpoints;
2214 delete [] yvertexpoints;
2215 delete [] xvert;
2216 delete [] yvert;
bf210566 2217 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2218 delete virtualvertex[i];
2219 /////////////////////////////////////////////////////////////
2220 return virtualcoolingtubesupport;
2221}
2222/////////////////////////////////////////////////////////////////////////////////
2223TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2224 /////////////////////////////////////////////////////////////
2225 // Method generating List containing SSD Hybrid Components
2226 /////////////////////////////////////////////////////////////
2227 TList* ssdhybridlist = new TList();
2228 const Int_t kssdstiffenernumber = 2;
2229 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2230 - 2.*fgkSSDModuleStiffenerPosition[1]
2231 - fgkSSDStiffenerWidth;
2232 Double_t ssdchipcablesradius[kssdstiffenernumber];
2233 for(Int_t i=0; i<kssdstiffenernumber; i++)
2234 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2235 - fgkSSDChipCablesHeight[0]
2236 - fgkSSDChipCablesHeight[1]);
2237 /////////////////////////////////////////////////////////////
2238 // Mother Volumes Containers
2239 /////////////////////////////////////////////////////////////
2240 const Int_t kmothernumber = 2;
3cf6a656 2241 const Int_t kmothervertexnumber = 8;
bf210566 2242 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2243 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
3cf6a656 2244
2245 TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
2246 TGeoVolume* ssdhybridmother[kmothernumber][2];
2247
2248 TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
2249 TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
2250 TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
2251
bf210566 2252 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2253 for(Int_t i=0; i<kmothernumber; i++){
3cf6a656 2254 xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
2255 ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
2256 xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
2257 ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2258 -fgkSSDChipCablesHeight[i+2];
2259
2260 xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
2261 ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
2262 xmothervertex[i][3] = xmothervertex[i][2];
5d9d4033 2263 ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1]+fgkSSDTolerance;
3cf6a656 2264
2265 xmothervertex[i][4] = xmothervertex[i][2]-0.4;
2266 ymothervertex[i][4] = ymothervertex[i][3];
2267 xmothervertex[i][5] = xmothervertex[i][4];
5d9d4033 2268 ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i]-fgkSSDTolerance;
3cf6a656 2269
2270 xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
2271 ymothervertex[i][6] = ymothervertex[i][5];
2272
2273 xmothervertex[i][7] = xmothervertex[i][6];
2274 ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
3cf6a656 2275 TGeoXtru *shape = new TGeoXtru(2);
2276 shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
2277 shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
2278 shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
2279 ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
2280 ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
2281 ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
bf210566 2282 }
2283 /////////////////////////////////////////////////////////////
2284 // SSD Stiffener
2285 /////////////////////////////////////////////////////////////
2286 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2287 0.5*fgkSSDStiffenerLength,
ca86fdb4 2288 0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
bf210566 2289 0.5*fgkSSDStiffenerHeight);
2290 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2291 fSSDStiffenerMedium);
2292 ssdstiffener->SetLineColor(fColorStiffener);
3cf6a656 2293
bf210566 2294////////////////////////////
2295// Capacitor 0603-2200 nF
2296///////////////////////////
2297 const Int_t knapacitor0603number = 5;
78e34526 2298 TGeoBBox* capacitor0603mothershape = new TGeoBBox("Capacitor0603MotherShape",
2299 0.5*fgkSSDCapacitor0603Length + fgkSSDCapacitor0603CapLength,
2300 0.5*fgkSSDCapacitor0603Width,
2301 0.5*fgkSSDCapacitor0603Height);
2302 TGeoVolume* capacitor0603mother = new TGeoVolume("Capacitor0603Mother",capacitor0603mothershape,
2303 fSSDAir);
2304
bf210566 2305 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
3cf6a656 2306 0.5*fgkSSDCapacitor0603Length,
78e34526 2307 0.5*fgkSSDCapacitor0603Width,
3cf6a656 2308 0.5*fgkSSDCapacitor0603Height);
bf210566 2309 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2310 fSSDStiffener0603CapacitorMedium);
2311 capacitor0603->SetLineColor(fColorAl);
78e34526 2312 TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.);
2313 capacitor0603mother->AddNode(capacitor0603,1,cap0603trans);
2314
2315 TGeoBBox* capacitor0603capshape = new TGeoBBox("Capacitor0603CapShape",
2316 0.5*fgkSSDCapacitor0603CapLength,
2317 0.5*fgkSSDCapacitor0603Width,
2318 0.5*fgkSSDCapacitor0603Height);
2319 TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape,
2320 fSSDStiffenerCapacitorCapMedium);
2321 capacitor0603cap->SetLineColor(fColorNiSn);
2322 TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.);
2323 capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1);
2324 TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.);
2325 capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2);
2326
3cf6a656 2327
2328 TGeoVolume* ssdchip = GetSSDChip();
2329
2330 const Int_t knedges = 5;
2331 TGeoVolume *ssdchipcables[2];
2332
bf210566 2333 for(Int_t i=0; i<kmothernumber; i++){
3cf6a656 2334 for(Int_t j=0; j<kssdstiffenernumber; j++){
2335 ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
2336 for(Int_t k=1; k<knapacitor0603number+1; k++){
78e34526 2337 ssdhybridmother[i][j]->AddNode(capacitor0603mother,k,
3cf6a656 2338 new TGeoCombiTrans("",
2339 -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
2340 -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
2341 (k-3.)/6*fgkSSDStiffenerLength,
2342 hybridmotherrotInv));
2343 }
2344 }
2345
2346 GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
2347 for(Int_t k=0; k<fgkSSDChipNumber; k++){
2348 TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
2349 - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
2350 - fgkSSDChipCablesHeight[i+2],
2351 (k+0.5-fgkSSDChipNumber/2)*
2352 (fgkSSDChipLength + fgkSSDChipSeparationLength));
2353 TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
2354 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
2355 (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
2356 hybridmotherrotInv);
bf210566 2357 for(Int_t j=0; j<kssdstiffenernumber; j++){
3cf6a656 2358 ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
2359 ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
2360 }
2361 }
2362 // Final placement by assembly
2363 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
2364 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
2365 ssdhybridlist->Add(ssdhybridassembly[i]);
bf210566 2366 }
3cf6a656 2367 /////////////////////////////////////////////////////////////
2368 // Mother Volume Containing Capacitor Part
2369 /////////////////////////////////////////////////////////////
bf210566 2370 const Int_t kcapacitormothernumber = 8;
2371 Double_t xcapacitorvertex[kcapacitormothernumber];
2372 Double_t ycapacitorvertex[kcapacitormothernumber];
2373 ///////////////////////
2374 // Setting the vertices
2375 ///////////////////////
2376 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2377 xcapacitorvertex[1] = xcapacitorvertex[0];
2378 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2379 xcapacitorvertex[3] = xcapacitorvertex[2];
2380 xcapacitorvertex[4] = xcapacitorvertex[0];
2381 xcapacitorvertex[5] = xcapacitorvertex[0];
2382 xcapacitorvertex[6] = -xcapacitorvertex[0];
2383 xcapacitorvertex[7] = xcapacitorvertex[6];
2384 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2385 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2386 ycapacitorvertex[2] = ycapacitorvertex[1];
2387 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2388 ycapacitorvertex[4] = ycapacitorvertex[3];
2389 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2390 ycapacitorvertex[6] = ycapacitorvertex[5];
2391 ycapacitorvertex[7] = ycapacitorvertex[0];
2392 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2393 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2394 ycapacitorvertex);
2395 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2396 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
ca86fdb4 2397// TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2398// fSSDAir);
2399 TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
d7599219 2400////////////////////////////
bf210566 2401// Connector
d7599219 2402///////////////////////////
78e34526 2403 const Int_t kssdconnectorlayernumber = 3;
2404 TGeoBBox* ssdconnectorshape[kssdconnectorlayernumber];
2405 Double_t ssdConnectorThickness[kssdconnectorlayernumber]={fgkSSDConnectorAlHeight,fgkSSDConnectorNiHeight,fgkSSDConnectorSnHeight};
2406 /*
bf210566 2407 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2408 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2409 + fgkSSDConnectorAlHeight};
78e34526 2410 */
2411 Double_t ssdconnectororigin[3] = {0,0,0.5*fgkSSDStiffenerHeight};
2412 const char* ssdconnectorname[kssdconnectorlayernumber] = {"SSDConnectorAl","SSDConnectorNi","SSDConnectorSn"};
2413 TGeoMedium *ssdConnectorMedium[kssdconnectorlayernumber]={fSSDAlTraceFlexMedium,fSSDStiffenerConnectorMedium,fSSDSn};
2414 TGeoVolume* ssdconnector[kssdconnectorlayernumber];
2415 for(Int_t i=0; i<kssdconnectorlayernumber; i++){
2416 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
bf210566 2417 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2418 0.5*fgkSSDConnectorWidth,
78e34526 2419 0.5*ssdConnectorThickness[i],
2420 ssdconnectororigin);
2421 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
bf210566 2422 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
78e34526 2423 ssdConnectorMedium[i]);
2424 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorNiSn);
bf210566 2425 }
78e34526 2426 const Int_t kssdconnectornumber = 4;
2427 TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
bf210566 2428 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2429 + fgkSSDConnectorPosition[0]
2430 - fgkSSDConnectorSeparation
2431 - 1.5*fgkSSDConnectorLength,
2432 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2433 - fgkSSDConnectorPosition[1]
2434 - ssdconnectorshape[0]->GetDY(),0.0);
2435 ssdconnectortrans[1] = new TGeoTranslation(
2436 - ssdstiffenershape->GetDX()
2437 + fgkSSDConnectorPosition[0]
2438 - 0.5*fgkSSDConnectorLength,
2439 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2440 - fgkSSDConnectorPosition[1]
2441 - ssdconnectorshape[0]->GetDY(),0.0);
2442 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2443 - fgkSSDConnectorPosition[0]
2444 + fgkSSDConnectorSeparation
2445 + 1.5*fgkSSDConnectorLength,
2446 -(ssdstiffenershape->GetDY()
2447 - fgkSSDConnectorPosition[1]
2448 - ssdconnectorshape[0]->GetDY()),0.0);
2449 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2450 - fgkSSDConnectorPosition[0]
2451 + 0.5*fgkSSDConnectorLength,
2452 -(ssdstiffenershape->GetDY()
2453 - fgkSSDConnectorPosition[1]
2454 - ssdconnectorshape[0]->GetDY()),0.0);
78e34526 2455 for(Int_t i=0; i<kssdconnectornumber; i++) {
2456 Int_t nlay = kssdconnectorlayernumber - 1;
2457 if (i == 1 || i == 2)
2458 nlay++;
2459 for(Int_t j=0; j<nlay; j++)
2460 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2461 }
bf210566 2462////////////////////////////
2463// Capacitor 1812-330 nF
2464///////////////////////////
78e34526 2465// Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2466 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2467 0.5*fgkSSDCapacitor1812Length,
2468 0.5*fgkSSDCapacitor1812Width,
78e34526 2469 0.5*fgkSSDCapacitor1812Height);
2470 // ssdcapacitor1812origin);
44285dfa 2471 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2472 fSSDStiffener1812CapacitorMedium);
2473 capacitor1812->SetLineColor(fColorAl);
bf210566 2474 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2475 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
78e34526 2476 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
bf210566 2477 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
78e34526 2478
2479 TGeoBBox* capacitor1812capshape = new TGeoBBox("Capacitor1812CapShape",
2480 0.5*fgkSSDCapacitor1812CapLength, 0.5*fgkSSDCapacitor1812Width,
2481 0.5*fgkSSDCapacitor1812Height);
2482 TGeoVolume* capacitor1812cap = new TGeoVolume("Capacitor1812Cap",capacitor1812capshape,
2483 fSSDStiffenerCapacitorCapMedium);
2484 capacitor1812cap->SetLineColor(fColorNiSn);
2485 TGeoTranslation* capacitor1812captrans1 = new TGeoTranslation(
2486 - capacitor1812shape->GetDX() - capacitor1812capshape->GetDX(),
2487 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2488 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2489 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2490 ssdhybridcapacitormother->AddNode(capacitor1812cap,1,capacitor1812captrans1);
2491 TGeoTranslation* capacitor1812captrans2 = new TGeoTranslation(
2492 capacitor1812shape->GetDX() + capacitor1812capshape->GetDX(),
2493 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2494 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2495 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2496 ssdhybridcapacitormother->AddNode(capacitor1812cap,2,capacitor1812captrans2);
2497
d7599219 2498////////////////////////////
2499//Hybrid Wire
2500////////////////////////////
44285dfa 2501 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2502 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2503 - fgkSSDConnectorSeparation;
44285dfa 2504 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2505 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
60e55aee 2506 Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2507
44285dfa 2508 Double_t wireangle = TMath::ATan(wirex/wirey);
2509 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2510 fgkSSDWireRadius, 0.5*ssdwireradius);
2511 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2512 fSSDStiffenerHybridWireMedium);
2513 hybridwire->SetLineColor(fColorPhynox);
2514 TGeoCombiTrans* hybridwirecombitrans[2];
2515 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2516 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2517 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2518 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2519 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2520 ssdstiffenershape->GetDZ()
78e34526 2521 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight+fgkSSDConnectorSnHeight,
d7599219 2522 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2523 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2524 0.0,
2525 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2526 0.0,
2527 new TGeoRotation("HybridWireRot2",
2528 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2529 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2530 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2531 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2532 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2533 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2534 /////////////////////////////////////////////////////////////
bf210566 2535 // Deallocating memory
44285dfa 2536 /////////////////////////////////////////////////////////////
bf210566 2537 delete hybridwirecombitrans[0];
2538 delete hybridwirecombitrans[1];
bf210566 2539 return ssdhybridlist;
2540 /////////////////////////////////////////////////////////////
2541}
2542///////////////////////////////////////////////////////////////////////////////
2543TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2544 /////////////////////////////////////////////////////////////
2545 // SSD Cooling Block System
2546 /////////////////////////////////////////////////////////////
2547 // SSD Cooling Block and Cooling Tube Transformations
2548 /////////////////////////////////////////////////////////////
2549 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2550 localcoolingblockrot->SetAngles(0.,90.,0.);
535e8862 2551 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
bf210566 2552 TVector3* coolingblocktransvector;
78e34526 2553 coolingblocktransvector = new TVector3(fgkCoolingTubeSeparation,
bf210566 2554 fgkSSDSensorLength
2555 - 2.*fgkSSDModuleStiffenerPosition[1]
2556 - fgkSSDCoolingBlockWidth);
2557 const Int_t kcoolingblocktransnumber = 2;
2558 const Int_t kcoolingblocknumber = 4;
2559 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
bf210566 2560 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2561 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
bf210566 2562 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
535e8862 2563 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
78e34526 2564 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X(),//+2*coolingtubedistance,
535e8862 2565 j*coolingblocktransvector->Y(),
2566 - 0.5*(fgkSSDCoolingBlockHoleCenter
2567 + fgkCoolingTubeRmax));
2568 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
535e8862 2569 }
d7599219 2570 }
ca86fdb4 2571 TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
bf210566 2572 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2573 /////////////////////////////////////////////////////////////
2574 // Adding Cooling block to mother volume
2575 /////////////////////////////////////////////////////////////
3cf6a656 2576 for(Int_t i=0; i<kcoolingblocknumber; i++){
2577 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
d7599219 2578 }
bf210566 2579 /////////////////////////////////////////////////////////////
2580 // Deallocating memory
2581 /////////////////////////////////////////////////////////////
3cf6a656 2582 delete coolingblocktransvector;
2583 delete localcoolingblockrot;
2584
2585 return coolingsystemother;
d7599219 2586}
2587/////////////////////////////////////////////////////////////////////////////////
bf210566 2588TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2589 /////////////////////////////////////////////////////////////
bf210566 2590 // SSD Flex
44285dfa 2591 /////////////////////////////////////////////////////////////
bf210566 2592 const Int_t kssdflexlayernumber = 2;
2593 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2594 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2595 const Int_t kmothervertexnumber = 17;
2596 Double_t xmothervertex[kmothervertexnumber];
2597 Double_t ymothervertex[kmothervertexnumber];
2598 /////////////////////////////////////////////
2599 // Auxiliary variables for vertex positioning
2600 /////////////////////////////////////////////
2601 const Int_t kssdflexboxnumber = 5;
44285dfa 2602 Double_t ssdflexboxlength[kssdflexboxnumber];
2603 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2604 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2605 * fgkSSDChipSeparationLength
2606 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2607 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2608 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2609 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2610 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2611 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2612 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2613 - ssdflexboxlength[1];
44285dfa 2614 Double_t ssdflexboxwidth[kssdflexboxnumber];
2615 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2616 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2617 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2618 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2619 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2620 ///////////////////////
2621 // Setting the vertices
2622 ///////////////////////
2623 xmothervertex[0] = 0.0;
2624 xmothervertex[1] = xmothervertex[0];
2625 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2626 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2627 + ssdflexboxlength[4];
2628 xmothervertex[4] = xmothervertex[3];
2629 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2630 xmothervertex[6] = xmothervertex[5];
2631 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2632 xmothervertex[8] = xmothervertex[7];
2633 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2634 xmothervertex[10] = xmothervertex[9];
2635 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2636 xmothervertex[12] = xmothervertex[11];
2637 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2638 xmothervertex[14] = xmothervertex[13];
2639 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2640 xmothervertex[16] = xmothervertex[15];
2641 ymothervertex[0] = 0.0;
2642 ymothervertex[1] = fgkSSDFlexWidth[1];
2643 ymothervertex[2] = fgkSSDFlexWidth[0];
2644 ymothervertex[3] = ymothervertex[2];
2645 ymothervertex[4] = ymothervertex[0];
2646 ymothervertex[5] = ymothervertex[4];
2647 ymothervertex[6] = ssdflexboxwidth[2];
2648 ymothervertex[7] = ymothervertex[6];
2649 ymothervertex[8] = ymothervertex[0];
2650 ymothervertex[9] = ymothervertex[8];
2651 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2652 ymothervertex[11] = ymothervertex[10];
2653 ymothervertex[12] = ymothervertex[0];
2654 ymothervertex[13] = ymothervertex[12];
2655 ymothervertex[14] = ymothervertex[7];
2656 ymothervertex[15] = ymothervertex[14];
2657 ymothervertex[16] = ymothervertex[0];
2658 /////////////////////////////////////////////////////////////
2659 // First Mother Volume containing SSDFlex
2660 /////////////////////////////////////////////////////////////
2661 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2662 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2663 ymothervertex);
2664 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2665 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
ca86fdb4 2666 TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2667// TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2668// fSSDAir);
bf210566 2669 /////////////////////////////////////////////////////////////
2670 // SSDFlex Layer Shapes
2671 /////////////////////////////////////////////////////////////
2672 for(Int_t i=0; i<kssdflexlayernumber; i++){
2673 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2674 ymothervertex);
2675 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2676 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2677 }
2678 /////////////////////////////////////
2679 // Setting Layers into Mother Volume
2680 /////////////////////////////////////
2681 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2682 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2683 fSSDKaptonFlexMedium};
2684 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2685 "AlFlexLay2","KaptonFlexLay2"};
2686 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2687 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2688 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2689 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2690 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2691 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2692 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2693 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2694 + fgkSSDFlexHeight[1]));
2695 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2696 }
bf210566 2697 return ssdflexmother;
d7599219 2698}
2699/////////////////////////////////////////////////////////////////////////////////
bf210566 2700TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2701 /////////////////////////////////////////////////////////////
2702 // Method generating SSD End Flex
d7599219 2703 /////////////////////////////////////////
bf210566 2704 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2705 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2706 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2707 * TMath::DegToRad()*ssdflexradiusmax
2708 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 2709 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2710 - 0.1*fgkSSDFlexFullLength;
bf210566 2711 const Int_t knedges = 20;
2712 const Int_t karcnumber = 2;
2713 TVector3* vertexposition[karcnumber*(knedges+1)];
2714 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2715 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2716 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2717 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2718 - 90.0*TMath::DegToRad()};
2719 TVector3* referencetrans[karcnumber];
2720 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2721 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2722 radius[0]);
2723 referencetrans[1] = new TVector3(referencetrans[0]->X()
2724 + fgkSSDFlexLength[2],
2725 - fgkSSDStiffenerHeight);
2726for(Int_t i=0; i<karcnumber; i++){
2727 for(Int_t j=0; j<knedges+1; j++){
2728 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2729 radius[i]*SinD(angle[i]));
2730 angle[i] += deltangle[i]*(1.0-2.0*i);
2731 }
2732 }
2733 ///////////////////////
2734 // Setting the vertices
2735 ///////////////////////
2736 const Int_t kendflexlayernumber = 4;
2737 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2738 TVector3** vertex[kendflexlayernumber];
2739 for(Int_t i=0; i<kendflexlayernumber; i++)
2740 vertex[i] = new TVector3*[kendflexvertexnumber];
2741 TVector3* transvector[kendflexlayernumber+1];
2742 TVector3* deltatransvector = new TVector3();
2743 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2744 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2745 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2746 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2747 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2748 * CosD(fgkSSDFlexAngle),
2749 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2750 * SinD(fgkSSDFlexAngle),0.0);
2751 *transvector[i] = *transvector[i-1]+*deltatransvector;
2752 }
2753 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2754 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2755 for(Int_t i=0; i<karcnumber; i++){
2756 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2757 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2758 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2759 /radius[i];
2760 }
2761 }
2762 for(Int_t i=0; i<kendflexlayernumber; i++){
2763 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2764 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2765 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2766 if(j<(knedges+1)){
2767 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2768 vertexposition[j]->Y()*ratioradius[0][i+1]);
2769 vertex[i][j+2]->RotateZ(referenceangle[0]);
2770 *vertex[i][j+2] += *referencetrans[0];
2771 vertex[i][4*(knedges+1)-j+1] =
2772 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2773 vertexposition[j]->Y()*ratioradius[0][i]);
2774 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2775 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2776 }
2777 else{
2778
2779 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2780 vertexposition[j]->Y()*ratioradius[1][i+1]);
2781 vertex[i][j+2]->RotateZ(referenceangle[1]);
2782 *vertex[i][j+2] += *referencetrans[1];
2783 vertex[i][4*(knedges+1)-j+1] =
2784 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2785 vertexposition[j]->Y()*ratioradius[1][i]);
2786 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2787 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2788 }
2789 }
2790 }
44285dfa 2791 /////////////////////////////////////////////////////////////
bf210566 2792 // First Mother Volume containing SSDEndFlex
2793 /////////////////////////////////////////////////////////////
2794 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2795 Double_t xmothervertex[kendflexvertexnumber];
2796 Double_t ymothervertex[kendflexvertexnumber];
2797 xmothervertex[0] = vertex[0][0]->X();
2798 ymothervertex[0] = vertex[0][0]->Y();
2799 for(Int_t i=1; i<kendflexvertexnumber; i++){
2800 if(i<2*(knedges+1)+2){
2801 xmothervertex[i] = vertex[3][i]->X();
2802 ymothervertex[i] = vertex[3][i]->Y();
2803 }
2804 else{
2805 xmothervertex[i] = vertex[0][i]->X();
2806 ymothervertex[i] = vertex[0][i]->Y();
2807 }
2808 }
2809 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2810 xmothervertex,ymothervertex);
2811 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2812 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
0fb26117 2813// TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2814// ssdendflexmothershape,fSSDAir);
2815 TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
bf210566 2816 //////////////////////////////////////
2817 // End Flex TGeoXtru Layer Definition
2818 //////////////////////////////////////
2819 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2820 TGeoVolume* ssdendflex[kendflexlayernumber];
2821 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2822 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2823 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2824 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2825 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2826 fSSDKaptonFlexMedium};
2827 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2828 "AlEndFlexLay2","KaptonEndFlexLay2"};
2829 for(Int_t i=0; i<kendflexlayernumber; i++){
2830 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2831 xvertex[i][j] = vertex[i][j]->X();
2832 yvertex[i][j] = vertex[i][j]->Y();
2833 }
2834 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2835 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2836 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2837 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2838 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2839 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2840 ssdendflexmother->AddNode(ssdendflex[i],1);
2841 }
44285dfa 2842 /////////////////////////////////////////////////////////////
bf210566 2843 // Deallocating memory
44285dfa 2844 /////////////////////////////////////////////////////////////
bf210566 2845 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2846 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2847 for(Int_t i=0; i<kendflexlayernumber; i++){
2848 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2849 delete [] vertex[i];
2850 }
2851 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2852 delete deltatransvector;
44285dfa 2853 /////////////////////////////////////////////////////////////
6727e2db 2854 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 2855 return ssdendflexmother;
d7599219 2856}
9b0c60ab 2857///////////////////////////////////////////////////////////////////////////////
bf210566 2858TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 2859 /////////////////////////////////////////////////////////////
9b0c60ab 2860 // Method generating the Mounting Block
bf210566 2861 /////////////////////////////////////////////////////////////
9b0c60ab 2862 const Int_t kvertexnumber = 8;
2863 Double_t xvertex[kvertexnumber];
2864 Double_t yvertex[kvertexnumber];
2865 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2866 xvertex[1] = xvertex[0];
2867 xvertex[2] = -xvertex[0];
2868 xvertex[3] = xvertex[2];
2869 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2870 - fgkSSDMountingBlockLength[2]);
2871 xvertex[5] = xvertex[4];
2872 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2873 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2874 - fgkSSDMountingBlockScrewHoleRadius[0];
2875 xvertex[7] = xvertex[6];
2876 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 2877 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 2878 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2879 yvertex[2] = yvertex[1];
2880 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2881 yvertex[4] = yvertex[3];
2882 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2883 - fgkSSDMountingBlockHeight[0];
2884 yvertex[6] = yvertex[5];
2885 yvertex[7] = yvertex[0];
160835d5 2886
9b0c60ab 2887 ///////////////////////////////////////////////////////////////////////
2888 // TGeoXTru Volume definition for Mounting Block Part
2889 ///////////////////////////////////////////////////////////////////////
2890 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2891 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2892 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2893 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 2894 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 2895 ssdmountingblockshape,
2896 fSSDMountingBlockMedium);
2897 ssdmountingblock->SetLineColor(fColorG10);
2898 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2899 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2900 TGeoRotation* mountingblockrot = new TGeoRotation();
2901 mountingblockrot->SetAngles(90.,180.,-90.);
2902 mountingblockcombitrans->SetRotation(*mountingblockrot);
2903 /////////////////////////////////////////////////////////////
2904 // Generating the Mounting Block Screw Vertices
2905 /////////////////////////////////////////////////////////////
2906 const Int_t kscrewvertexnumber = 15;
2907 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
2908 - fgkSSDMountingBlockScrewHoleEdge)
2909 / fgkSSDMountingBlockScrewHoleRadius[0])
2910 * TMath::RadToDeg();
2911 Double_t phi0 = 90.+alpha;
2912 Double_t phi = 270.-2*alpha;
2913 Double_t deltaphi = phi/kscrewvertexnumber;
2914 TVector3* screwvertex[kscrewvertexnumber+1];
2915 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
2916 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
2917 *CosD(phi0+i*deltaphi),
2918 fgkSSDMountingBlockScrewHoleRadius[0]
2919 *SinD(phi0+i*deltaphi));
2920 Double_t xscrewvertex[kscrewvertexnumber+6];
2921 Double_t yscrewvertex[kscrewvertexnumber+6];
2922 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
2923 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
2924 - fgkSSDMountingBlockScrewHoleEdge);
2925 xscrewvertex[1] = xscrewvertex[0];
2926 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2927 xscrewvertex[2] = screwvertex[0]->X();
2928 yscrewvertex[2] = yscrewvertex[1];
2929 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
2930 xscrewvertex[i+3] = screwvertex[i]->X();
2931 yscrewvertex[i+3] = screwvertex[i]->Y();
2932 }
2933 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2934 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
2935 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
2936 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
2937 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
2938 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
2939 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
2940 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
2941 + fgkSSDMountingBlockHeight[2]);
2942 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
2943 ssdmountingblockscrewshape,
2944 fSSDMountingBlockMedium);
2945 ssdmountingblockscrew->SetLineColor(fColorG10);
2946 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
2947 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
2948 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2949 - yscrewvertex[1],
2950 0.5*fgkSSDMountingBlockHeight[0]
2951 - fgkSSDMountingBlockHeight[2]
2952 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2953 + fgkSSDMountingBlockHeight[2]
2954 - yvertex[0]));
2955 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2956 -0.5*fgkSSDMountingBlockScrewHoleEdge,
2957 yscrewvertex[1]
2958 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2959 +fgkSSDMountingBlockHeight[2]
2960 -yvertex[0]));
2961 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2962 yscrewvertex[1],
2963 - 0.5*fgkSSDMountingBlockHeight[0]
2964 + fgkSSDMountingBlockHeight[2]
2965 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2966 + fgkSSDMountingBlockHeight[2]
2967 - yvertex[0]));
2968 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2969 yscrewvertex[1],
2970 - yscrewvertex[1]
2971 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2972 + fgkSSDMountingBlockHeight[2]
2973 - yvertex[0]));
2974 TGeoRotation* ssdmountingblockscrewrot[4];
2975 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
2976 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
2977 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
2978 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
2979 for(Int_t i=1; i<4; i++)
2980 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
2981 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
2982 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
2983 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
2984 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
2985 + xvertex[0],yscrewvertex[1]
2986 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2987 + fgkSSDMountingBlockHeight[2]
2988 - yvertex[0]),0.);
2989 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
2990 for(Int_t i=0; i<4; i++){
2991 ssdmountingblockscrewmatrix[i] =
2992 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
2993 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
2994 }
2995 ///////////////////////////////////////////////////////////////////////
2996 // TGeoXtru for Mother Volume
2997 ///////////////////////////////////////////////////////////////////////
2998 const Int_t kvertexmothernumber = 12;
2999 Double_t xmothervertex[kvertexmothernumber];
3000 Double_t ymothervertex[kvertexmothernumber];
3001 for(Int_t i=0; i<6; i++){
3002 xmothervertex[i] = xvertex[i];
3003 ymothervertex[i] = yvertex[i];
3004 }
3005 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3006 ymothervertex[6] = ymothervertex[5];
3007 xmothervertex[7] = xmothervertex[6];
5d9d4033 3008 ymothervertex[7] = ymothervertex[4] - fgkSSDTolerance;
9b0c60ab 3009 xmothervertex[8] = xmothervertex[7]
3010 + 0.5*(fgkSSDMountingBlockLength[1]
3011 - fgkSSDMountingBlockLength[2]);
5d9d4033 3012 ymothervertex[8] = ymothervertex[7];
9b0c60ab 3013 xmothervertex[9] = xmothervertex[8];
3014 ymothervertex[9] = ymothervertex[2];
3015 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3016 ymothervertex[10] = ymothervertex[1];
3017 xmothervertex[11] = xmothervertex[10];
3018 ymothervertex[11] = ymothervertex[0];
3019 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3020 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3021 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3022 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3023 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3024 ssdmountingblockmothershape,
3025 fSSDAir);
3026 /////////////////////////////////////////////////////////////
3027 // Placing the Volumes into Mother Volume
3028 /////////////////////////////////////////////////////////////
3029 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3030 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3031 for(Int_t i=0; i<4; i++)
3032 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3033 ssdmountingblockscrewmatrix[i]);
3034 /////////////////////////////////////////////////////////////
3035 // Deallocating memory
3036 /////////////////////////////////////////////////////////////
3037 delete mountingblockrot;
3038 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3039 delete ssdmountingblockglobalrot;
3040 delete ssdmountingblockglobaltrans;
3041 /////////////////////////////////////////////////////////////
3042 return ssdmountingblockmother;
3043}
3044///////////////////////////////////////////////////////////////////////////////
3045 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3046 /////////////////////////////////////////////////////////////
3047 // Method generating the Mounting Block Clip
3048 /////////////////////////////////////////////////////////////
3049 const Int_t kmothervertexnumber = 10;
3050 Double_t xmothervertex[kmothervertexnumber];
3051 Double_t ymothervertex[kmothervertexnumber];
3052 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3053 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3054 xmothervertex[1] = xmothervertex[0];
3055 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3056 - fgkMountingBlockClibScrewRadius);
3057 xmothervertex[3] = xmothervertex[2];
3058 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3059 xmothervertex[5] = xmothervertex[4];
3060 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3061 xmothervertex[7] = xmothervertex[6];
3062 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3063 xmothervertex[9] = xmothervertex[8];
3064 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 3065 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 3066 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3067 ymothervertex[2] = ymothervertex[1];
3068 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3069 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3070 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3071 ymothervertex[4] = ymothervertex[3];
3072 ymothervertex[5] = ymothervertex[2];
3073 ymothervertex[6] = ymothervertex[5];
3074 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3075 ymothervertex[8] = ymothervertex[7];
3076 ymothervertex[9] = ymothervertex[0];
160835d5 3077
9b0c60ab 3078 ///////////////////////////////////////////////////////////////////////
3079 // TGeoXTru Volume definition for Mounting Block Clip Part
3080 ///////////////////////////////////////////////////////////////////////
3081 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3082 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3083 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3084 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3085 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3086 ssdmountingblockclipshape,fSSDAir);
3087 ssdmountingblockclip->SetLineColor(4);
3088 ///////////////////////////////////////////////////////////////////////
3089 // TGeoXTru Volume definition for Clip
3090 ///////////////////////////////////////////////////////////////////////
3091 const Int_t kclipvertexnumber = 6;
3092 Double_t xclipvertex[kclipvertexnumber];
3093 Double_t yclipvertex[kclipvertexnumber];
3094 xclipvertex[0] = xmothervertex[0];
3095 xclipvertex[1] = xclipvertex[0];
3096 xclipvertex[2] = xmothervertex[6];
3097 xclipvertex[3] = xclipvertex[2];
3098 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3099 xclipvertex[5] = xclipvertex[4];
3100 yclipvertex[0] = ymothervertex[0];
3101 yclipvertex[1] = ymothervertex[1];
3102 yclipvertex[2] = yclipvertex[1];
3103 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3104 yclipvertex[4] = yclipvertex[3];
3105 yclipvertex[5] = yclipvertex[0];
3106 TGeoXtru* clipshape = new TGeoXtru(2);
3107 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3108 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3109 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3110 + fgkMountingBlockClibWidth);
3111 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3112 clip->SetLineColor(18);
3113 ///////////////////////////////////////////////////////////////////////
3114 // Ladder Support Piece
3115 ///////////////////////////////////////////////////////////////////////
3116 const Int_t ksupportvertexnumber = 4;
3117 Double_t xsupportvertex[ksupportvertexnumber];
3118 Double_t ysupportvertex[ksupportvertexnumber];
3119 xsupportvertex[0] = xclipvertex[5];
3120 xsupportvertex[1] = xsupportvertex[0];
3121 xsupportvertex[2] = xmothervertex[9];
3122 xsupportvertex[3] = xsupportvertex[2];
3123 ysupportvertex[0] = yclipvertex[0];
3124 ysupportvertex[1] = yclipvertex[3];
3125 ysupportvertex[2] = ysupportvertex[1];
3126 ysupportvertex[3] = ysupportvertex[0];
3127 TGeoXtru* supportshape = new TGeoXtru(2);
3128 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3129 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3130 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3131 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3132 support->SetLineColor(9);
3133 ///////////////////////////////////////////////////////////////////////
3134 // TGeoXTru Volume definition for Screw
3135 ///////////////////////////////////////////////////////////////////////
3136 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3137 0.5*fgkMountingBlockClibScrewRadius};
3138 Int_t edgesnumber[2] = {50,6};
3139 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3140 +0.5*(ymothervertex[3]-ymothervertex[2])};
851c0ce3 3141 TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
9b0c60ab 3142 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3143 clipscrew->SetLineColor(12);
3144 TGeoRotation* screwrot = new TGeoRotation();
3145 screwrot->SetAngles(0.,90.,0.);
3146 TGeoTranslation* screwtrans = new TGeoTranslation();
3147 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3148 0.5*(ymothervertex[3]+ymothervertex[2]),
3149 0.5*fgkSSDMountingBlockWidth+
3150 -0.5*fgkMountingBlockSupportWidth[0]);
3151 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3152 ///////////////////////////////////////////////////////////////////////
3153 // Placing the Volumes
3154 ///////////////////////////////////////////////////////////////////////
3155 ssdmountingblockclip->AddNode(clip,1);
3156 ssdmountingblockclip->AddNode(support,1);
3157 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3158 /////////////////////////////////////////////////////////////
3159 // Deallocating memory
3160 /////////////////////////////////////////////////////////////
3161 delete screwtrans;
3162 delete screwrot;
3163 /////////////////////////////////////////////////////////////
3164 return ssdmountingblockclip;
d7599219 3165}
bf210566 3166///////////////////////////////////////////////////////////////////////////////
cd2243fb 3167void AliITSv11GeometrySSD::CreateCoolingTubes() {
44285dfa 3168 /////////////////////////////////////////////////////////////
bf210566 3169 // Method generating the Cooling Tube
cd2243fb 3170 // sets fcoolingtube and returns list for endladdercoolingtube
44285dfa 3171 /////////////////////////////////////////////////////////////
cd2243fb 3172 TGeoTube *coolingtubeshape[2];
3173 // Ladder Cooling Tubes
3174
3175 // MvL: Simplified cooling tubes
3176 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
3177 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
3178
3179 // End Ladder Cooling Tubes
3180 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3181 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3182 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3183
3184 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
3185 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3186 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
3187 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3188 endladdercoolingtubeshape[0][0]->GetDz());
3189 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3190 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
3191 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3192 endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
3193 // Ladder Cooling Tubes
3194 TGeoVolume* coolingtube[2];
3195 coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
3196 coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
3197 coolingtube[0]->SetLineColor(fColorPhynox);
3198 coolingtube[1]->SetLineColor(fColorWater);
3199
3200 // End Ladder Cooling Tubes
3201 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3202 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3203 endladdercoolingtube[i] = new TGeoVolume*[2];
3204 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3205 endladdercoolingtubeshape[0][0],
3206 fSSDCoolingTubePhynox);
3207 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3208 endladdercoolingtubeshape[0][1],
3209 fSSDCoolingTubeWater);
3210 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3211 endladdercoolingtubeshape[1][0],
3212 fSSDCoolingTubePhynox);
3213 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3214 endladdercoolingtubeshape[1][1],
3215 fSSDCoolingTubeWater);
3216 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3217 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3218 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3219 }
0fb26117 3220
bf210566 3221 /////////////////////////////////////////////////////////////
3222 // Virtual Volume containing Cooling Tubes
3223 /////////////////////////////////////////////////////////////
9b0c60ab 3224 // Ladder Cooling Tubes
cd2243fb 3225 TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
3226 coolingtubeshape[0]->GetRmax(),
3227 coolingtubeshape[0]->GetDz());
3228 fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
3229 fcoolingtube->AddNode(coolingtube[0],1);
3230 fcoolingtube->AddNode(coolingtube[1],1);
3231
9b0c60ab 3232 // End Ladder Cooling Tubes
3233 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3234 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
cd2243fb 3235 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3236 endladdercoolingtubeshape[i][0]->GetRmax(),
3237 endladdercoolingtubeshape[i][0]->GetDz());
3238 fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3239 endladdervirtualcoolingtubeshape[0],
3240 fSSDAir);
3241 fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3242 endladdervirtualcoolingtubeshape[1],
3243 fSSDAir);
3244 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3245 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3246 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3247 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
d7599219 3248}
bf210566 3249///////////////////////////////////////////////////////////////////////////////
3250TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3251 /////////////////////////////////////////////////////////////
bf210566 3252 // Method generating SSD Cooling Block
44285dfa 3253 /////////////////////////////////////////////////////////////
bf210566 3254 const Int_t kvertexnumber = 8;
3255 ///////////////////////////////////////
3256 // Vertex Positioning for TGeoXTru
3257 ///////////////////////////////////////
3258 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3259 vertexposition[0] = new TVector3(0.0,0.0);
3260 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3261 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3262 vertexposition[1]->Y());
3263 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3264 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3265 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3266 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3267 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3268 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3269 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3270 - fgkSSDCoolingBlockHoleLength[0]
3271 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3272 fgkSSDCoolingBlockHeight[0]
3273 - fgkSSDCoolingBlockHoleRadius[1],
3274 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3275 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3276 - fgkSSDCoolingBlockHoleLength[0]),
3277 vertexposition[6]->Y());
3278 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3279 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3280 Double_t phi = 180.-alpha;
3281 Double_t psi = 180.+2.*alpha;
3282 Double_t deltapsi = psi/nedges;
3283 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3284 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3285 fgkSSDCoolingBlockHoleCenter);
3286 for(Int_t i=0; i<nedges+1; i++){
3287 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3288 radius*SinD(phi+i*deltapsi));
3289 *vertexposition[kvertexnumber+i] += (*transvector);
3290 }
3291 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3292 for(Int_t i=0; i<kvertexnumber; i++)
3293 vertexposition[kvertexnumber+nedges+1+i] =
3294 GetReflection(vertexposition[kvertexnumber-1-i],param);
3295 ///////////////////////////////////////////////////////////////////////
3296 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3297 ///////////////////////////////////////////////////////////////////////
3298 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3299 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3300 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3301 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3302 xvertexpoints[i] = vertexposition[i]->X();
3303 yvertexpoints[i] = vertexposition[i]->Y();
3304 }
3305 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3306 yvertexpoints);
3307 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3308 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3309 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3310 ssdcoolingblockshape,
3311 fSSDAlCoolBlockMedium);
3312 ssdcoolingblock->SetLineColor(fColorAl);
3313 /////////////////////////////////////////////////////////////
3314 // Deallocating memory
3315 /////////////////////////////////////////////////////////////
3316 delete [] vertexposition;
7b208ef4 3317 delete [] xvertexpoints;
3318 delete [] yvertexpoints;
bf210566 3319 /////////////////////////////////////////////////////////////
3320 return ssdcoolingblock;
3321}
3322/////////////////////////////////////////////////////////////////////////////////
3cf6a656 3323void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
d7599219 3324 ///////////////////////////////////////////////////////
cd2243fb 3325 static const Int_t kssdchipcablesnumber = 2; // Number of cables: left and right
3326 static const Int_t kssdchipcableslaynumber = 2; // Number of layers: Al and Kapton
3327 static const Int_t kvertexnumber = 4*(nedges+1)+4;
bf210566 3328 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3329 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
cd2243fb 3330 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
bf210566 3331 - fgkSSDChipCablesHeight[0]
3332 - fgkSSDChipCablesHeight[1]);
3333 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3334 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3335 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3336 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3337 - ssdchipcablesradius[0]
3338 - fgkSSDChipCablesWidth[1]
3339 - fgkSSDChipCablesWidth[2]);
3340 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3341 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3342 + fgkSSDChipCablesHeight[1]
3343 + fgkSSDSensorHeight);
d7599219 3344 ///////////////////////////////////////////////////////
bf210566 3345 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3346 ///////////////////////////////////////////////////////
3347 TVector3** vertexposition[kssdchipcableslaynumber];
3348 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3349 new TVector3*[4*(nedges+1)+4];
3350 Double_t ratio[4];
3351 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3352 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3353 / ssdchipcablesradius[0];
3354 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3355 / ssdchipcablesradius[0];
3356 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3357 + fgkSSDChipCablesHeight[1])
3358 / ssdchipcablesradius[0];
3359 Double_t phi = 180.;
3360 Double_t deltaphi = 180./nedges;
3361 Double_t angle = 0.0;
045be90c 3362
3363 Double_t xvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3364 Double_t yvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3365
bf210566 3366 TVector3* vertex = new TVector3();
3367 TVector3* transvector[kssdchipcableslaynumber];
3368 transvector[0] = new TVector3(fgkSSDChipWidth,
cd2243fb 3369 SSDChipCablesHeight-ssdchipcablesradius[0]);
bf210566 3370 transvector[1] = new TVector3();
cd2243fb 3371 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
3372 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
3373 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
bf210566 3374 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3375 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3376 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3377 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3378 transvector[1]->SetY(ssdchipcablesradius[0]
3379 + fgkSSDChipCablesHeight[0]
3380 + fgkSSDChipCablesHeight[1]);
3381 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
cd2243fb 3382 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
bf210566 3383 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
cd2243fb 3384 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
bf210566 3385 - i*fgkSSDChipCablesHeight[0]);
3386 vertexposition[i][2*(nedges+1)+2] =
3387 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3388 + fgkSSDChipCablesWidth[1]
3389 + fgkSSDChipCablesWidth[2],
3390 ((1.-i)*fgkSSDChipCablesHeight[i]
3391 + fgkSSDChipCablesHeight[1]));
3392 vertexposition[i][2*(nedges+1)+3] =
3393 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3394 vertexposition[i][2*(nedges+1)+2]->Y()
3395 - fgkSSDChipCablesHeight[i]);
3396 for(Int_t j=0; j<nedges+1; j++){
3397 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3398 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3399 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3400 vertexposition[0][(nedges+1)*i+j+2] =
3401 new TVector3(*vertex+*transvector[i]);
3402 vertexposition[1][(nedges+1)*i+j+2] =
3403 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3404 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3405 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3406 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3407 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3408 new TVector3(vertex->X()*ratio[2*i+1]
3409 + transvector[i]->X(),
3410 vertex->Y()*ratio[2*i+1]
3411 + transvector[i]->Y());
3412 }
3413 }
3414 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3415 for(Int_t j=0; j<kvertexnumber; j++){
3416 xvertexpoints[i][j] = vertexposition[i][j]->X();
3417 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3418 }
3419 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3420 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3421 xvertexpoints[i],yvertexpoints[i]);
3422 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3423 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3424 ssdchipcable[kssdchipcablesnumber*k+i] =
3425 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3426 ssdchipcableshape[kssdchipcablesnumber*k+i],
3427 (kssdchipcablesnumber*k+i)%2==0?
3428 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3429 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3430 }
3431 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3432 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3433 }
44285dfa 3434 /////////////////////////////////////////////////////////////
bf210566 3435 // Mother Volume definition
3436 /////////////////////////////////////////////////////////////
cd2243fb 3437 static const Int_t kmothervertexnumber = 8;
3438 Double_t xmothervertex[kmothervertexnumber];
3439 Double_t ymothervertex[kmothervertexnumber];
3440 xmothervertex[0] = xvertexpoints[0][1];
3441 ymothervertex[0] = yvertexpoints[0][1];
3442 xmothervertex[1] = xvertexpoints[0][2+nedges/2];
3443 ymothervertex[1] = yvertexpoints[0][1];
3444 xmothervertex[2] = xvertexpoints[0][2+nedges/2];
3445 ymothervertex[2] = yvertexpoints[0][2+nedges];
3446 xmothervertex[3] = xvertexpoints[0][3+nedges];
3447 ymothervertex[3] = yvertexpoints[0][3+nedges];
3448 xmothervertex[4] = xvertexpoints[0][3+2*nedges];
5d9d4033 3449 ymothervertex[4] = yvertexpoints[0][3+2*nedges]+fgkSSDTolerance;
cd2243fb 3450 xmothervertex[5] = xvertexpoints[0][4+2*nedges];
5d9d4033 3451 ymothervertex[5] = yvertexpoints[0][4+2*nedges]+fgkSSDTolerance;
cd2243fb 3452 xmothervertex[6] = xvertexpoints[1][5+2*nedges];
3453 ymothervertex[6] = yvertexpoints[1][5+2*nedges];
3454 xmothervertex[7] = xvertexpoints[0][1];
3455 ymothervertex[7] = yvertexpoints[1][5+2*nedges];
3456 TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
3457 ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3458 ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3459 ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3460
3cf6a656 3461 cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
3462 cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
cd2243fb 3463
3cf6a656 3464 cableL->AddNode(ssdchipcable[0],1);
3465 cableL->AddNode(ssdchipcable[1],1);
3466 cableR->AddNode(ssdchipcable[2],1);
3467 cableR->AddNode(ssdchipcable[3],1);
cd2243fb 3468
bf210566 3469 /////////////////////////////////////////////////////////////
3470 // Deallocating memory
3471 /////////////////////////////////////////////////////////////
bf210566 3472 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3473 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3474 delete vertex;
bf210566 3475 /////////////////////////////////////////////////////////////
d7599219 3476}
5bf92139 3477//_____________________________________________________________________________
3cf6a656 3478TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
44285dfa 3479 /////////////////////////////////////////////////////////////
bf210566 3480 // SSD Chip Assembly Generation
3481 /////////////////////////////////////////////////////////////
bf210566 3482 TGeoBBox* ssdchipcompshape[2];
3483 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3484 0.5*fgkSSDChipLength,
3485 0.5*fgkSSDChipWidth,
3486 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3487 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3488 0.5*fgkSSDChipLength,
3489 0.5*fgkSSDChipWidth,
3490 0.5*fgkSSDChipGlueHeight);
3491 TGeoVolume* ssdchipcomp[2];
3492 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3493 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3494 fSSDChipGlueMedium);
3495 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3496 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3497 TGeoTranslation* ssdchipcomptrans[2];
3498 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3499 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3500 /////////////////////////////////////////////////////////////
3501 // Virtual Volume containing SSDChip
3502 /////////////////////////////////////////////////////////////
3503 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3504 0.5*fgkSSDChipWidth,
3505 0.5*fgkSSDChipHeight);
e21cdd03 3506 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
bf210566 3507 /////////////////////////////////////////////////////////////
3508 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3cf6a656 3509 return ssdchip;
d7599219 3510}
bf210566 3511/////////////////////////////////////////////////////////////////////////////////
3512TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3513 /////////////////////////////////////////////////////////////
bf210566 3514 // Method returning a List containing pointers to Ladder Cable Volumes
cd2243fb 3515 //
3516 // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
3517 // each contains 2 volumes, one for polyamide and one for aluminium
44285dfa 3518 /////////////////////////////////////////////////////////////
bf210566 3519 const Int_t kladdercablesegmentnumber = 2;
3520 /////////////////////////////////////////
3521 // LadderSegmentBBox Volume
3522 /////////////////////////////////////////
160835d5 3523 static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
bf210566 3524 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3525 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
160835d5 3526
3527
3528 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3529 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3530 static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3531
3532 static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
3533 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3534 0.5*fgkSSDFlexWidth[0],
3535 0.5*fgkSSDLadderCableWidth,
78e34526 3536 0.5*fgkSSDLadderCableHeight[0]),
160835d5 3537 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3538 0.5*fgkSSDFlexWidth[0],
3539 0.5*fgkSSDLadderCableWidth,
78e34526 3540 fgkSSDLadderCableHeight[0]
3541 +0.5*fgkSSDLadderCableHeight[1])
160835d5 3542 };
3543 static TGeoVolume* laddercablesegmentbboxassembly = new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
3544 static TGeoVolume* laddercablesegmentarbassembly =
3545 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3546
3547 static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3548 static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3549
3550 if (laddercablesegmentbboxshape[0] == 0) {
3551 // Initialise static shapes and volumes
bf210566 3552 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3553 new TGeoBBox(laddercablesegmentbboxshapename[i],
3554 0.5*fgkSSDFlexWidth[0],
3555 0.5*fgkSSDLadderCableWidth,
78e34526 3556 0.5*fgkSSDLadderCableHeight[i]);
160835d5 3557
bf210566 3558 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3559 laddercablesegmentbbox[i] =
3560 new TGeoVolume(laddercablesegmentbboxname[i],
3561 laddercablesegmentbboxshape[i],
3562 (i==0?fSSDAlTraceLadderCableMedium:
3563 fSSDKaptonLadderCableMedium));
3564 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3565 fColorPolyhamide);
3566 }
160835d5 3567
bf210566 3568 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3569 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3570 laddercablesegmentbboxtrans[i]);
3571/////////////////////////////////////////
3572// LadderSegmentArb8 Volume
3573/////////////////////////////////////////
3574 const Int_t kvertexnumber = 4;
3575 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3576 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3577 new TVector3*[kvertexnumber];
3578//Shape Vertex Positioning
3579 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3580 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3581 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3582 i*fgkSSDFlexHeight[0]);
3583 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3584 + fgkSSDFlexHeight[1]
3585 + i*fgkSSDFlexHeight[0]);
3586 laddercablesegmentvertexposition[i][3] =
3587 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3588 laddercablesegmentvertexposition[i][2]->Y());
3589 }
3590 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3591 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
a6e0ebfe 3592 const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
bf210566 3593 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
160835d5 3594
bf210566 3595 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3596 GetArbShape(laddercablesegmentvertexposition[i],
3597 laddercablesegmentwidth[i],
3598 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3599 laddercablesegmentarbshapename[i]);
3600 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3601 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
160835d5 3602
bf210566 3603 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3604 laddercablesegmentarb[i] =
3605 new TGeoVolume(laddercablesegmentarbname[i],
3606 laddercablesegmentarbshape[i],
3607 (i==0?fSSDAlTraceLadderCableMedium:
3608 fSSDKaptonLadderCableMedium));
3609 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3610 fColorPolyhamide);
d7599219 3611}
bf210566 3612 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3613 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3614 90.,90,-90.);
3615 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3616 0.,90.,0.);
3617 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3618 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3619 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3620 + fgkSSDFlexWidth[0],0.,0.,
3621 new TGeoRotation((*laddercablesegmentarbrot[1])
3622 *(*laddercablesegmentarbrot[0])));
bf210566 3623 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3624 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3625 laddercablesegmentarbcombitrans);
160835d5 3626 } // End of static initialisations
bf210566 3627/////////////////////////////////////////
3628// End Ladder Cable Volume
160835d5 3629// Note: this part depends explicitly on the length passed as an argument to the function
bf210566 3630/////////////////////////////////////////
3631 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3632 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3633 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3634 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3635 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3636 0.5*ssdendladdercablelength,
3637 0.5*fgkSSDLadderCableWidth,
78e34526 3638 0.5*fgkSSDLadderCableHeight[i]);
bf210566 3639 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3640 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3641 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3642 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3643 ladderendcablesegmentbbox[i] =
3644 new TGeoVolume(ladderendcablesegmentbboxname[i],
3645 ladderendcablesegmentbboxshape[i],
3646 (i==0?fSSDAlTraceLadderCableMedium:
3647 fSSDKaptonLadderCableMedium));
3648 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3649 fColorPolyhamide);
3650 }
3651 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3652 ladderendcablesegmentbboxtrans[0] =
3653 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
3654 0.5*ssdendladdercablelength,
3655 0.5*fgkSSDLadderCableWidth,
78e34526 3656 0.5*fgkSSDLadderCableHeight[0]);
bf210566 3657 ladderendcablesegmentbboxtrans[1] =
3658 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
3659 0.5*ssdendladdercablelength,
3660 0.5*fgkSSDLadderCableWidth,
78e34526 3661 fgkSSDLadderCableHeight[0]
3662 +0.5*fgkSSDLadderCableHeight[1]);
bf210566 3663 TGeoVolume* ladderendcablesegmentbboxassembly =
3664 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
3665 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3666 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
3667 ladderendcablesegmentbboxtrans[i]);
3668/////////////////////////////////////////
3669 TList* laddercablesegmentlist = new TList();
3670 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
3671 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
3672 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
3673 return laddercablesegmentlist;
160835d5 3674}
3675
bf210566 3676/////////////////////////////////////////////////////////////////////////////////
3677TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 3678 /////////////////////////////////////////////////////////////
cd2243fb 3679 // Method generating Ladder Cable of given length (n modules + end)
3680 // Called by GetLadderCableAssembly
44285dfa 3681 /////////////////////////////////////////////////////////////
bf210566 3682 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
3683 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
3684 for(Int_t i=0; i<n; i++){
3685 TGeoTranslation* laddercabletrans = new TGeoTranslation(
3686 i*(fgkCarbonFiberJunctionWidth),
3687 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
78e34526 3688 i*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
bf210566 3689 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
cd2243fb 3690 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
3691
d7599219 3692 }
bf210566 3693 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
3694 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
cd2243fb 3695 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
78e34526 3696 (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
bf210566 3697 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
3698 return laddercable;
3699}
3700/////////////////////////////////////////////////////////////////////////////////
3701TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
cd2243fb 3702 ///////////////////////////////////////////////////////////////////
3703 // Main method generating Ladder Cable bundles containing n cables
3704 ///////////////////////////////////////////////////////////////////
3705 Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
78e34526 3706 Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])};
3707 TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]),cableOrig);
cd2243fb 3708 TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
a3f8715e 3709 char laddercabletransname[100];
bf210566 3710 for(Int_t i=0; i<n; i++){
045be90c 3711 snprintf(laddercabletransname,100,"LadderCableTrans%i",i+1);
3712 laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
3713 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
d7599219 3714 }
cd2243fb 3715 return laddercable;
bf210566 3716}
3717/////////////////////////////////////////////////////////////////////////////////
3718TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
3719 /////////////////////////////////////////////////////////////
3720 // Method generating Ladder Cable List Assemblies
cd2243fb 3721 // containing two cables bundles, i.e. P+N readout for one endcap
bf210566 3722 /////////////////////////////////////////////////////////////
cd2243fb 3723 const Int_t kladdercableassemblynumber = 2;
bf210566 3724 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
3725 TGeoVolume* ladderCable[kladdercableassemblynumber];
a3f8715e 3726 char laddercableassemblyname[100];
bf210566 3727 TList* laddercableassemblylist = new TList();
3728 for(Int_t i=0; i<kladdercableassemblynumber; i++){
045be90c 3729 snprintf(laddercableassemblyname,100,"LadderCableAssembly%i",i+1);
bf210566 3730 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
3731 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
3732 new TGeoCombiTrans((n-1)
3733 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3734 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
3735 0.,new TGeoRotation("",180,0.,0.)));
3736 laddercableassemblylist->Add(ladderCable[i]);
3737}
3738 return laddercableassemblylist;
3739}
3740///////////////////////////////////////////////////////////////////////////////
3741void AliITSv11GeometrySSD::SetLadderSegment(){
3742 /////////////////////////////////////////////////////////////
3743 // Method Generating Ladder Segment Array
3744 /////////////////////////////////////////////////////////////
3745 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
3746 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
cd2243fb 3747
3748 /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
3749 TGeoXtru *laddersegmentshape = new TGeoXtru(2);
3750 static const Int_t ntrianglevtx = 3;
3751 Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
3752 Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
3753 laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
3754 laddersegmentshape->DefineSection(0,0);
3755 laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth); // MVL
3756 fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
3757 fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
3758 */
3759
bf210566 3760 if(!fCreateMaterials) CreateMaterials();
3761 if(!fTransformationMatrices) CreateTransformationMatrices();
3762 if(!fBasicObjects) CreateBasicObjects();
3763 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
3764 // Placing Carbon Fiber Support
3765 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
3766 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3767 fcarbonfibersupportmatrix[j]);
3768 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3769 fcarbonfibersupportmatrix[j]);
d7599219 3770 }
bf210566 3771 // Placing Carbon Fiber Junction
cd2243fb 3772 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
bf210566 3773 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
3774 fcarbonfiberjunctionmatrix[j]);
cd2243fb 3775 }
bf210566 3776 // Placing Carbon Fiber Lower Support
cd2243fb 3777 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
bf210566 3778 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
3779 fcarbonfiberlowersupportrans[j]);
cd2243fb 3780 }
bf210566 3781 // Placing SSD Sensor Support
3782 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
cd2243fb 3783 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
bf210566 3784 fssdsensorsupport[1][i],
3785 j+1,fssdsensorsupportmatrix[j]);
3786 // Placing SSD Cooling Tube Support
3787 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
3788 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3789 fcoolingtubesupportmatrix[j]);
3790 // Placing SSD Cooling Tube
cd2243fb 3791 fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
3792 fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
bf210566 3793 // Placing SSD Hybrid
3794 switch(i){
3795 case 0:
3796 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
3797 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3798 break;
3799 case 1:
3800 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
3801 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3802 break;
3803 }
3804 // Placing Cooling Block System
cd2243fb 3805 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
bf210566 3806 // Placing SSD Flex
cd2243fb 3807 for(Int_t j=0; j<fgkflexnumber; j++){
3808 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
3809 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
3810 }
bf210566 3811 }
d7599219 3812}
bf210566 3813///////////////////////////////////////////////////////////////////////////////
3814void AliITSv11GeometrySSD::SetEndLadderSegment(){
3815 /////////////////////////////////////////////////////////////
3816 // Method Generating End Ladder
3817 /////////////////////////////////////////////////////////////
3818 // End Ladder Carbon Fiber Junction
3819 /////////////////////////////////////////////////////////////
3820 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
3821 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
3822 if(!fCreateMaterials) CreateMaterials();
3823 if(!fTransformationMatrices) CreateTransformationMatrices();
3824 if(!fBasicObjects) CreateBasicObjects();
3825 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
b28b5356 3826 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
bf210566 3827 fendladdersegment[i]->AddNode(j==2 ?
3828 fendladdercarbonfiberjunction[i][1] :
3829 fendladdercarbonfiberjunction[i][0],
3830 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
3831 }
3832 /////////////////////////////////////////////////////////////
3833 // End Ladder Carbon Fiber Support
3834 /////////////////////////////////////////////////////////////
3835 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
3836 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
3837 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3838 fendladdercarbonfibermatrix[i][j]);
3839 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3840 fendladdercarbonfibermatrix[i][j]);
3841 }
3842 /////////////////////////////////////////////////////////////
3843 // End Ladder Mounting Block
3844 /////////////////////////////////////////////////////////////
9b0c60ab 3845 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3846 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
e21cdd03 3847 fendladdermountingblockcombitrans[i]);
9b0c60ab 3848 /////////////////////////////////////////////////////////////
e5bf64ae 3849 // End Ladder Mounting Block Clip
9b0c60ab 3850 /////////////////////////////////////////////////////////////
3851 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3852 for(Int_t j=0; j<2; j++)
e21cdd03 3853 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
3854 fendladdermountingblockclipmatrix[i][j]);
bf210566 3855 /////////////////////////////////////////////////////////////
3856 // End Ladder Lower Supports
44285dfa 3857 /////////////////////////////////////////////////////////////
bf210566 3858 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
e21cdd03 3859 fendladderlowersupptrans[0]);
bf210566 3860 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
e21cdd03 3861 fendladderlowersupptrans[1]);
bf210566 3862 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
e21cdd03 3863 fendladderlowersupptrans[2]);
9b0c60ab 3864 /////////////////////////////////////////////////////////////
3865 // End Ladder Cooling Tube Support
3866 /////////////////////////////////////////////////////////////
3867 for(Int_t i=0; i<2; i++)
3868 for(Int_t j=0; j<(i==0?4:2); j++)
e21cdd03 3869 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3870 fendladdercoolingtubesupportmatrix[i][j]);
9b0c60ab 3871 /////////////////////////////////////////////////////////////
3872 // End Ladder Cooling Tube Support
3873 /////////////////////////////////////////////////////////////
cd2243fb 3874 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
3875 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
3876 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
3877 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
bf210566 3878}
3879///////////////////////////////////////////////////////////////////////////////
3880void AliITSv11GeometrySSD::SetLadder(){
3881 /////////////////////////////////////////////////////////////
3882 // Method Generating Ladder of Layer 5 and 6
44285dfa 3883 /////////////////////////////////////////////////////////////
bf210566 3884 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
3885 fgkSSDLay6SensorsNumber};
3886 /////////////////////////////////////////////////////////////////////////////
3887 /// Generating Ladder Mother Volume Containing Ladder
3888 /////////////////////////////////////////////////////////////////////////////
3889 TGeoXtru* laddershape[fgkladdernumber];
3890 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
3891 const Int_t kmothervertexnumber = 8;
3892 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
3893 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
3894 ///////////////////////
3895 // Setting the vertices
3896 ///////////////////////
3897 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
78e34526 3898 * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]);
bf210566 3899 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
0fb26117 3900 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
bf210566 3901 xmothervertex[0][1] = xmothervertex[0][0];
78e34526 3902 ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010
bf210566 3903 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
3904 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
3905 ymothervertex[0][2] = ymothervertex[0][1];
3906 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
3907 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
3908 xmothervertex[0][4] = -xmothervertex[0][3];
3909 ymothervertex[0][4] = ymothervertex[0][3];
3910 xmothervertex[0][5] = -xmothervertex[0][2];
3911 ymothervertex[0][5] = ymothervertex[0][2];
3912 xmothervertex[0][6] = -xmothervertex[0][1];
3913 ymothervertex[0][6] = ymothervertex[0][1];
3914 xmothervertex[0][7] = -xmothervertex[0][0];
3915 ymothervertex[0][7] = ymothervertex[0][0];
3916 for(Int_t i=0; i<kmothervertexnumber; i++){
3917 xmothervertex[1][i] = xmothervertex[0][i];
3918 ymothervertex[1][i] = ymothervertex[0][i];
3919 }
0fb26117 3920///////////////////////////////////////////////////////////////////////////
3921// Disalignement Mother Volume corrections 25/08/08
3922///////////////////////////////////////////////////////////////////////////
160835d5 3923 TGeoXtru* leftladdershape1[fgkladdernumber];
3924 TGeoXtru* leftladdershape2[fgkladdernumber];
0fb26117 3925 TGeoXtru* centersensorladdershape[fgkladdernumber];
160835d5 3926 TGeoXtru* rightladdershape1[fgkladdernumber];
3927 TGeoXtru* rightladdershape2[fgkladdernumber];
bf210566 3928 for(Int_t i=0; i<fgkladdernumber; i++){
160835d5 3929 leftladdershape1[i] = new TGeoXtru(2);
3930 leftladdershape2[i] = new TGeoXtru(2);
3931 centersensorladdershape[i] = new TGeoXtru(2);
3932 rightladdershape1[i] = new TGeoXtru(2);
3933 rightladdershape2[i] = new TGeoXtru(2);
3934 }
0fb26117 3935 //////////////////////////////////////
160835d5 3936 // Setting the names for shapes
0fb26117 3937 //////////////////////////////////////
160835d5 3938 leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
3939 leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
3940 leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
3941 leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
0fb26117 3942 centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
3943 centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
160835d5 3944 rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
3945 rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
3946 rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
3947 rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
0fb26117 3948 //////////////////////////////////////
160835d5 3949 Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
3950 Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
0fb26117 3951 Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
3952 Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
160835d5 3953 Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
3954 Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
3955 for(Int_t i=0; i<fgkladdernumber; i++) {
3956 for(Int_t j=0; j<kmothervertexnumber; j++){
3957 xcentersensorvertex[i][j] = xmothervertex[i][j];
3958 ycentersensorvertex[i][j] = ymothervertex[i][j];
3959 xend1laddervertex[i][j] = xmothervertex[i][j];
3960 yend1laddervertex[i][j] = ymothervertex[i][j];
3961 xend2laddervertex[i][j] = xmothervertex[i][j];
3962 yend2laddervertex[i][j] = ymothervertex[i][j];
3963 }
3964 // Add some space around sensors to accommodate misalignments
3965 xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
3966 xcentersensorvertex[i][1] = xcentersensorvertex[0][0];
3967 xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
3968 xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
3969
3970 ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
3971 ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
3972
3973 // Center Ladder Piece
3974 centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
3975 ycentersensorvertex[i]);
3976 centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3977 + 1.45*fgkSSDMountingBlockWidth);
3978 centersensorladdershape[i]->DefineSection(1, ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
3979 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
3980 - 2.4*fgkSSDMountingBlockWidth);
0fb26117 3981
160835d5 3982 // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
0fb26117 3983
160835d5 3984 // Cuts off first corner (neg x)
3985 xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
3986 xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
3987 // Cuts off last part (pos x)
3988 xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
3989 xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
0fb26117 3990
160835d5 3991 leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3992 yend1laddervertex[i]);
3993 leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
3994 leftladdershape1[i]->DefineSection(1, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3995 - fgkEndLadderMountingBlockPosition[0]);
3996
3997 leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3998 yend2laddervertex[i]);
3999 leftladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4000 - fgkEndLadderMountingBlockPosition[0]);
4001 leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
4002 + 1.45*fgkSSDMountingBlockWidth); // connect to main volume at -1.6725 cm
4003
4004 rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4005 yend1laddervertex[i]);
4006 rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4007 +fgkEndLadderCarbonFiberLowerJunctionLength[0]
4008 -2.4*fgkSSDMountingBlockWidth);
4009 rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4010 + fgkEndLadderMountingBlockPosition[1]);
4011
4012 rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4013 yend2laddervertex[i]);
4014 rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4015 + fgkEndLadderMountingBlockPosition[1]);
4016 rightladdershape2[i]->DefineSection(1, ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4017 + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4018 }
4019 TGeoCompositeShape* laddershapecontainer[2];
4020 laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4021 "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4022 "+Lay5CenterSensorContainer"
4023 "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4024 laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4025 "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4026 "+Lay6CenterSensorContainer"
4027 "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4028 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4029 for(Int_t i=0; i<fgkladdernumber; i++){
4030 fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4031 fladder[i]->SetLineColor(4);
4032 }
bf210566 4033///////////////////////////////////////////////////////////////////////////
4034 if(!fCreateMaterials) CreateMaterials();
4035 if(!fTransformationMatrices) CreateTransformationMatrices();
4036 if(!fBasicObjects) CreateBasicObjects();
4037 SetLadderSegment();
4038 SetEndLadderSegment();
4039 for(Int_t i=0; i<fgkladdernumber; i++){
4040 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4041 //////////////////////////
4042 /// Placing Ladder Segment
4043 //////////////////////////
4044 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4045 fladdersegment[i==0 ? 1 : 0],
4046 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4047 //////////////////////////
4048 /// Placing SSD Sensor
4049 //////////////////////////
ca86fdb4 4050 if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
bf210566 4051 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4052 fssdsensormatrix[i][j]);
4053 }
4054 ///////////////////////////////
4055 /// Placing End Ladder Segment
4056 ///////////////////////////////
160835d5 4057 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
bf210566 4058 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4059 }
d7599219 4060/////////////////////////////////////////////////////////////////////////////
4061/// Placing Ladder Cables
4062/////////////////////////////////////////////////////////////////////////////
bf210566 4063 Int_t sidecablenumber[2][2];
4064 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4065 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4066 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4067 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4068 Double_t carbonfibertomoduleposition[3];
4069 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4070 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4071 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4072 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4073 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4074 - fgkSSDSensorCenterSupportThickness[0]);
4075 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4076 + 0.5*fgkCoolingTubeSupportHeight
4077 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4078 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4079 Double_t ssdendladdercablelength[4];
4080 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4081 + fgkSSDSensorLength
4082 - fgkSSDModuleStiffenerPosition[1]
4083 - fgkSSDStiffenerWidth
4084 - fgkSSDFlexWidth[0]
bf210566 4085 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4086 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4087 + fgkSSDModuleStiffenerPosition[1]
4088 + fgkSSDStiffenerWidth
bf210566 4089 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4090 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4091 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4092 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4093 - kendladdercablecorrection;
44285dfa 4094 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4095 + carbonfibertomoduleposition[1]
d7599219 4096 - fgkSSDModuleStiffenerPosition[1]
4097 - fgkSSDStiffenerWidth)
bf210566 4098 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
78e34526 4099
44285dfa 4100 TList* laddercableassemblylist[4];
4101 const Int_t kendladdercablesnumber = 4;
cd2243fb 4102 TGeoRotation *laddercablerot = new TGeoRotation();
4103 laddercablerot->SetAngles(90.,60.,-90.);
bf210566 4104 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4105 for(Int_t j=0; j<kendladdercablesnumber; j++){
4106 laddercableassemblylist[j] =
4107 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4108 ssdendladdercablelength[j]);
0fb26117 4109 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4110 j<2?1:2,fladdercablematrix[i][j]);
bf210566 4111 }
bf210566 4112}
4113////////////////////////////////////////////////////////////////////////////////
4114void AliITSv11GeometrySSD::SetLayer(){
d7599219 4115////////////////////////////////////////////////////////////////////////////////
bf210566 4116 // Creating Ladder of Layer 5 and Layer 6
4117 /////////////////////////////////////////////////////////////
4118 if(!fCreateMaterials) CreateMaterials();
4119 if(!fTransformationMatrices) CreateTransformationMatrices();
4120 if(!fBasicObjects) CreateBasicObjects();
4121 SetLadder(); // Generating the ladder of Layer5 and Layer6
4122 const Int_t kssdlayladdernumber[fgklayernumber] =
4123 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4124 /////////////////////////////////////////////////////////////
4125 // Generating mother volumes for Layer5 and Layer6
4126 /////////////////////////////////////////////////////////////
e5bf64ae 4127 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4128 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
bf210566 4129 Int_t *ladderindex[fgklayernumber];
4130 Int_t index[fgklayernumber] = {8,9};
4131 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4132 for(Int_t i=0; i<fgklayernumber; i++)
4133 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4134 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4135 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4136 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4137 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4138 }
44285dfa 4139 /////////////////////////////////////////////////////////////
bf210566 4140 // Deallocating memory
4141 /////////////////////////////////////////////////////////////
7b208ef4 4142 for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
d7599219 4143}
4144////////////////////////////////////////////////////////////////////////////////
4145void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4146 /////////////////////////////////////////////////////////////
4147 // Insert the layer 5 in the mother volume.
4148 /////////////////////////////////////////////////////////////
4149 if (! moth) {
160835d5 4150 AliError("Can't insert layer5, mother is null!\n");
44285dfa 4151 return;
4152 };
bf210566 4153 if(!fSSDLayer5) SetLayer();
4154 fMotherVol = moth;
4155 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4156 + fgkLay5CenterITSPosition);
4157 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4158 }
d7599219 4159////////////////////////////////////////////////////////////////////////////////
4160void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4161 /////////////////////////////////////////////////////////////
4162 // Insert the layer 6 in the mother volume.
4163 /////////////////////////////////////////////////////////////
4164 if (! moth) {
160835d5 4165 AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
44285dfa 4166 return;
4167 };
bf210566 4168 if(!fSSDLayer6) SetLayer();
4169 fMotherVol = moth;
4170 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4171 + fgkLay6CenterITSPosition);
4172 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4173 }
bf210566 4174 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4175 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4176 /////////////////////////////////////////////////////////////
4177 // Method generating the Arc structure of Ladder Support
4178 /////////////////////////////////////////////////////////////
4179 const Int_t kssdlayladdernumber[fgklayernumber] =
4180 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4181 Double_t mountingsupportedge[fgklayernumber];
4182 Double_t mountingblockratio[fgklayernumber];
4183 Double_t theta[fgklayernumber];
4184 Double_t phi[fgklayernumber];
4185 Double_t psi0[fgklayernumber];
4186 Double_t deltapsi[fgklayernumber];
4187 TVector3* mountingsupportedgevector[fgklayernumber];
4188 for(Int_t i=0; i<fgklayernumber; i++){
4189 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4190 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4191 * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4192 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4193 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4194 / kssdlayladdernumber[i])));
4195 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4196 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4197 mountingsupportedgevector[i] = new TVector3();
60e55aee 4198 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4199 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4200 (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4201 (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
9b0c60ab 4202 psi0[i] = 0.5*TMath::Pi()-phi[i];
4203 deltapsi[i] = (theta[i]+phi[i])/nedges;
4204 }
4205 TVector3** vertex[fgklayernumber];
4206 TList* vertexlist[fgklayernumber];
4207 Int_t indexedge[fgklayernumber] = {0,0};
4208 for(Int_t i=0; i<fgklayernumber; i++){
4209 vertex[i] = new TVector3*[nedges+1];
4210 vertexlist[i] = new TList();
4211 }
4212 for(Int_t i=0; i<fgklayernumber; i++){
4213 for(Int_t j=0; j<nedges+1; j++){
4214 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4215 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4216 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4217 vertexlist[i]->Add(vertex[i][j]);
4218 }
4219 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4220 }
4221 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4222 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4223 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4224 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4225 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4226 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4227 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4228 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4229 for(Int_t i=0; i<fgklayernumber; i++){
4230 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4231 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4232 xcentervertex[i] = new Double_t[indexedge[i]+3];
4233 ycentervertex[i] = new Double_t[indexedge[i]+3];
4234 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4235 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4236 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4237 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4238 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4239 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4240 ((TVector3*)vertexlist[i]->At(j))->X();
4241 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4242 ((TVector3*)vertexlist[i]->At(j))->Y();
4243 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4244 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4245 if(j<indexedge[i]+1){
4246 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4247 ((TVector3*)vertexlist[i]->At(j))->X();
4248 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4249 ((TVector3*)vertexlist[i]->At(j))->Y();
4250 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4251 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4252 }
4253 }
4254 xsidevertex[i][1] = xsidevertex[i][0];
4255 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4256 xsidevertex[i][2] = xsidevertex[i][3];
4257 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4258 xcentervertex[i][1] = xcentervertex[i][0];
4259 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4260 xcentervertex[i][2] = xcentervertex[i][3];
4261 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4262 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4263 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4264 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4265 ycenterlowervertex[i][0] = ysidevertex[i][0];
4266 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4267 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4268 }
4269 /////////////////////////////////////////////////////////////
4270 // Building the Arc Structure of Ladder Supports
4271 /////////////////////////////////////////////////////////////
4272 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4273 TGeoXtru* centermountingsupportshape[fgklayernumber];
4274 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4275 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4276 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4277 TGeoVolume* centermountingblocksupport[fgklayernumber];
4278 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4279 TGeoVolume* centerladdersupportpiece[fgklayernumber];
a3f8715e 4280 char sidemountingblockname[100];
4281 char centermountingblockname[100];
4282 char sideladdersupportpiecename[100];
4283 char centerladdersupportpiecename[100];
9b0c60ab 4284 for(Int_t i=0; i<fgklayernumber; i++){
045be90c 4285 snprintf(sidemountingblockname,100,"MountingBlockSupportSideLay%dArc",i+5);
4286 snprintf(centermountingblockname,100,"MountingBlockSupportCenterLay%dArc",i+5);
4287 snprintf(sideladdersupportpiecename,100,"SideLadderSupportPieceLay%d",i+5);
4288 snprintf(centerladdersupportpiecename,100,"CenterLadderSupportPieceLay%d",i+5);
4289 sidemountingblocksupportshape[i] = new TGeoXtru(2);
9b0c60ab 4290 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4291 xsidevertex[i],ysidevertex[i]);
4292 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4293 -fgkMountingBlockSupportWidth[0]);
4294 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4295 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4296 sidemountingblocksupportshape[i],
4297 fSSDAlCoolBlockMedium);
4298 sidemountingblocksupport[i]->SetLineColor(9);
4299 centermountingsupportshape[i] = new TGeoXtru(2);
4300 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4301 xcentervertex[i],ycentervertex[i]);
4302 centermountingsupportshape[i]->DefineSection(0,0.);
4303 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4304 -fgkMountingBlockSupportWidth[0]);
160835d5 4305
9b0c60ab 4306 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4307 centermountingsupportshape[i],
4308 fSSDAlCoolBlockMedium);
4309 centermountingblocksupport[i]->SetLineColor(9);
4310 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4311 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4312 xsidelowervertex[i],ysidelowervertex[i]);
4313 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4314 -fgkMountingBlockSupportWidth[0]);
4315 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4316 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4317 sideladdersupportpieceshape[i],
e21cdd03 4318 fSSDCarbonFiberMedium);
9b0c60ab 4319 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4320 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4321 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4322 xcenterlowervertex[i],ycenterlowervertex[i]);
4323 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4324 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4325 -fgkMountingBlockSupportWidth[0]);
4326 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4327 centerladdersupportpieceshape[i],
e21cdd03 4328 fSSDCarbonFiberMedium);
9b0c60ab 4329 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4330 }
4331 /////////////////////////////////////////////////////////////
4332 // Building the Up Structure of Ladder Supports
4333 /////////////////////////////////////////////////////////////
4334 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4335 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4336 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4337 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4338 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4339 //////////////////////////////////////////////////////////
4340 // Setting the volume for TGeoXtru Mounting Block Piece
4341 //////////////////////////////////////////////////////////
4342 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4343 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4344 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4345 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4346 TGeoVolume* mountingblockpieceup[fgklayernumber];
4347 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4348 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4349 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4350 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
a3f8715e 4351 char mountingblockpiecedownname[100];
4352 char mountingblockpieceupname[100];
9b0c60ab 4353 for(Int_t i=0; i<fgklayernumber; i++){
4354 ///////////////////////////
4355 // Mounting Block Down Vertex
4356 ///////////////////////////
4357 mountingblockpiecedownshape[i] = new TGeoXtru(2);
045be90c 4358 snprintf(mountingblockpiecedownname,100,"MountingBlockPieceDownLay%d",i+5);
9b0c60ab 4359 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4360 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4361 + fgkMountingBlockSupportDownHeight
4362 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4363 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4364 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4365 + fgkSSDMountingBlockHeight[1]
4366 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4367 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4368 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4369 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4370 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4371 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4372 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4373 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4374 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4375 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4376 + fgkSSDMountingBlockHeight[2]
4377 - fgkSSDMountingBlockHeight[0];
4378 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4379 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4380 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4381 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4382 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4383 mountingblockpiecedownyvertex[i]);
4384 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4385 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4386 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
e21cdd03 4387 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
9b0c60ab 4388 mountingblockpiecedown[i]->SetLineColor(fColorG10);
160835d5 4389
9b0c60ab 4390 ///////////////////////////
4391 // Mounting Block Up Vertex
4392 ///////////////////////////
4393 mountingblockpieceupshape[i] = new TGeoXtru(2);
045be90c 4394 snprintf(mountingblockpieceupname,100,"MountingBlockPieceUpLay%d",i+5);
9b0c60ab 4395 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4396 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4397 + fgkMountingBlockSupportUpHeight[i]
4398 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4399 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4400 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4401 + fgkSSDMountingBlockHeight[1]
4402 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4403 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4404 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4405 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4406 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4407 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4408 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4409 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4410 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4411 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4412 + fgkSSDMountingBlockHeight[2]
4413 - fgkSSDMountingBlockHeight[0];
4414 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4415 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4416 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4417 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
160835d5 4418
9b0c60ab 4419 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4420 mountingblockpieceupyvertex[i]);
4421 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4422 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4423 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
e21cdd03 4424 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
9b0c60ab 4425 mountingblockpieceup[i]->SetLineColor(fColorG10);
4426 }
4427 ///////////////////////////////////////////////////////////////////
4428 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4429 ///////////////////////////////////////////////////////////////////
4430 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4431 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4432 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4433 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4434 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4435 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4436 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4437 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
a3f8715e 4438 char mountingblocksupportrapezoidowname[100];
4439 char mountingblocksupportrapezoidupname[100];
9b0c60ab 4440 Double_t scalefactor = 3./4.;
4441 for(Int_t i=0; i<fgklayernumber; i++){
4442 ////////////////////////////////////////////
4443 // Mounting Block Support Down Trapezoid Vertex
4444 ////////////////////////////////////////////
4445 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4446 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4447 - mountingsupportedge[i];
4448 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4449 mountingblocksupportrapezoidownxvertex[i][1] =
4450 mountingblocksupportrapezoidownxvertex[i][0];
4451 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4452 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4453 - mountingblockpiecedownyvertex[i][0]);
4454 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4455 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4456 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4457 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4458 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4459 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
160835d5 4460
9b0c60ab 4461 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4462 mountingblocksupportrapezoidownyvertex[i]);
4463 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4464 -fgkMountingBlockSupportWidth[0]);
4465 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
045be90c 4466 snprintf(mountingblocksupportrapezoidowname,100,"MountingBlockSuppTrapezoidDownLay%d",i+5);
9b0c60ab 4467 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
e21cdd03 4468 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4469 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4470 ////////////////////////////////////////////
4471 // Mounting Block Support Up Trapezoid Vertex
4472 ////////////////////////////////////////////
4473 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4474 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4475 - mountingsupportedge[i];
4476 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4477 mountingblocksupportrapezoidupxvertex[i][1] =
4478 mountingblocksupportrapezoidupxvertex[i][0];
4479 mountingblocksupportrapezoidupyvertex[i][1] =
4480 mountingblockpieceupyvertex[i][0]
4481 + scalefactor*(mountingblockpieceupyvertex[i][1]
4482 - mountingblockpieceupyvertex[i][0]);
4483 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4484 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4485 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4486 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4487 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4488 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
160835d5 4489
9b0c60ab 4490 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4491 mountingblocksupportrapezoidupyvertex[i]);
4492 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4493 -fgkMountingBlockSupportWidth[0]);
4494 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
045be90c 4495 snprintf(mountingblocksupportrapezoidupname,100,"MountingBlockSuppTrapezoidUpLay%d",i+5);
9b0c60ab 4496 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
e21cdd03 4497 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4498 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4499 }
4500 ///////////////////////////////////////////////////////////////////
4501 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4502 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4503 Double_t boxoriginup[fgklayernumber][2][3];
4504 Double_t boxorigindown[fgklayernumber][2][3];
a3f8715e 4505 char mountingblocksupportboxdownname[100];
4506 char mountingblocksupportboxupname[100];
9b0c60ab 4507 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4508 mountingblocksupportrot->SetAngles(90.,180.,-90);
4509 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4510 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4511 TGeoHMatrix* laddersupportmatrix[2];
4512 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4513 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4514 /////////////////////////////////////////////////////////////
4515 // Creating Mother Volume for Containment
4516 /////////////////////////////////////////////////////////////
4517 Double_t *xmothervertex[fgklayernumber];
4518 Double_t *ymothervertex[fgklayernumber];
4519 for(Int_t i=0; i<fgklayernumber; i++){
4520 xmothervertex[i] = new Double_t[8];
4521 ymothervertex[i] = new Double_t[8];
4522 }
4523 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4524 TGeoVolume* downmotherladdersupport[fgklayernumber];
4525 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
160835d5 4526 TGeoVolume* upmotherladdersupport[fgklayernumber];
a3f8715e 4527 char upmotheladdersupportname[100];
4528 char downmotheladdersupportname[100];
9b0c60ab 4529 for(Int_t i=0; i<fgklayernumber; i++){
4530 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4531 - mountingsupportedge[i];
4532 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4533 xmothervertex[i][1] = xmothervertex[i][0];
4534 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4535 + fgkMountingBlockSupportWidth[0];
4536 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4537 ymothervertex[i][2] = ymothervertex[i][1];
4538 xmothervertex[i][3] = xmothervertex[i][2];
4539 ymothervertex[i][3] = -ymothervertex[i][0];
4540 xmothervertex[i][4] = -xmothervertex[i][0];
4541 ymothervertex[i][4] = ymothervertex[i][3];
4542 xmothervertex[i][5] = xmothervertex[i][4];
4543 ymothervertex[i][5] = -ymothervertex[i][1];
4544 xmothervertex[i][6] = -xmothervertex[i][2];
4545 ymothervertex[i][6] = ymothervertex[i][5];
4546 xmothervertex[i][7] = xmothervertex[i][6];
4547 ymothervertex[i][7] = ymothervertex[i][0];
160835d5 4548
045be90c 4549 snprintf(downmotheladdersupportname,100,"LadderSupportDownLay%d",i+5);
4550 snprintf(upmotheladdersupportname,100,"LadderSupportUpLay%d",i+5);
160835d5 4551
4552 downmotherladdersupportshape[i] = new TGeoXtru(2);
9b0c60ab 4553 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4554 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
160835d5 4555 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
9b0c60ab 4556 + fgkMountingBlockSupportDownHeight
4557 + fgkSSDMountingBlockHeight[1]
4558 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4559 - fgkSSDModuleCoolingBlockToSensor
4560 - fgkSSDLadderVerticalDisalignment);
4561
4562// - fgkSSDModuleVerticalDisalignment);
4563 //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4564
4565 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4566 downmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4567 upmotherladdersupportshape[i] = new TGeoXtru(2);
4568 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4569 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4570 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4571 + fgkMountingBlockSupportUpHeight[i]
4572 + fgkSSDMountingBlockHeight[1]
4573 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4574 - fgkSSDModuleCoolingBlockToSensor
4575 - fgkSSDLadderVerticalDisalignment);
4576
4577 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4578 upmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4579 }
4580 for(Int_t i=0; i<fgklayernumber; i++){
4581 /////////////////////////
4582 // Setting the box origin
4583 /////////////////////////
4584 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4585 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4586 + 0.5*fgkMountingBlockSupportDownHeight
4587 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4588 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4589 - 0.5*fgkMountingBlockSupportWidth[0];
4590
4591 boxorigindown[i][1][0] = 0.0;
4592 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4593 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4594 - fgkMountingBlockSupportWidth[0]);
4595
4596 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4597 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4598 + 0.5*fgkMountingBlockSupportUpHeight[i]
4599 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4600 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4601 - 0.5*fgkMountingBlockSupportWidth[0];
4602
4603 boxoriginup[i][1][0] = 0.0;
160835d5 4604 boxoriginup[i][1][1] = boxoriginup[i][0][1];
9b0c60ab 4605 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4606 - fgkMountingBlockSupportWidth[0]);
4607
4608 /////////////////////////
4609 // Setting the boxes
4610 /////////////////////////
4611 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4612 + fgkSSDMountingBlockLength[0]),
160835d5 4613 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4614 0.5*fgkMountingBlockSupportWidth[0],
4615 boxorigindown[i][0]);
160835d5 4616 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4617 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4618 0.5*(fgkMountingBlockSupportWidth[1]
4619 - fgkMountingBlockSupportWidth[0]),
4620 boxorigindown[i][1]);
4621
4622 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4623 + fgkSSDMountingBlockLength[0]),
160835d5 4624 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4625 0.5*fgkMountingBlockSupportWidth[0],
4626 boxoriginup[i][0]);
160835d5 4627
9b0c60ab 4628 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
160835d5 4629 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4630 0.5*(fgkMountingBlockSupportWidth[1]
4631 - fgkMountingBlockSupportWidth[0]),
4632 boxoriginup[i][1]);
4633 ///////////////////////////////////////
160835d5 4634 // Adding the Volumes to Mother Volume
9b0c60ab 4635 ///////////////////////////////////////
4636 for(Int_t j=0; j<2; j++){
045be90c 4637 snprintf(mountingblocksupportboxdownname,100,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4638 snprintf(mountingblocksupportboxupname,100,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4639 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4640 mountingblocksupportboxdownshape[i][j],
4641 fSSDCarbonFiberMedium);
4642 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4643 mountingblocksupportboxupshape[i][j],
4644 fSSDCarbonFiberMedium);
9b0c60ab 4645 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4646 mountingblocksupportboxup[i][j]->SetLineColor(9);
4647 for(Int_t k=0; k<2; k++){
4648 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
160835d5 4649 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
9b0c60ab 4650 }
4651 }
4652 for(Int_t k=0; k<2; k++){
4653 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4654 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4655 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4656 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
160835d5 4657 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4658 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4659 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
160835d5 4660 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4661 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4662 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4663 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4664 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4665 }
4666 }
4667 TList* laddersupportlist = new TList();
4668 laddersupportlist->Add(downmotherladdersupport[0]);
4669 laddersupportlist->Add(upmotherladdersupport[0]);
4670 laddersupportlist->Add(downmotherladdersupport[1]);
4671 laddersupportlist->Add(upmotherladdersupport[1]);
4672 /////////////////////////////////////////////////////////////
4673 // Deallocating memory
4674 /////////////////////////////////////////////////////////////
4675 for(Int_t i=0; i<fgklayernumber; i++){
4676 for(Int_t j=0; j<nedges+1; j++)
4677 delete vertex[i][j];
4678 delete mountingsupportedgevector[i];
4679 delete [] vertex[i];
4680 delete vertexlist[i];
4681 delete [] xsidevertex[i];
4682 delete [] ysidevertex[i];
4683 delete [] xcentervertex[i];
4684 delete [] ycentervertex[i];
4685 delete [] xsidelowervertex[i];
4686 delete [] ysidelowervertex[i];
4687 delete [] xcenterlowervertex[i];
4688 delete [] ycenterlowervertex[i];
7b208ef4 4689 delete [] xmothervertex[i];
4690 delete [] ymothervertex[i];
9b0c60ab 4691 }
3e008bd7 4692 delete [] xsidevertex;
4693 delete [] ysidevertex;
4694 delete [] xcentervertex;
4695 delete [] ycentervertex;
4696 delete [] xsidelowervertex;
4697 delete [] ysidelowervertex;
4698 delete [] xcenterlowervertex;
4699 delete [] ycenterlowervertex;
9b0c60ab 4700 delete globalrefladdersupportrot;
4701 delete mountingblocksupportrot;
4702 /////////////////////
4703 return laddersupportlist;
4704}
4705 ////////////////////////////////////////////////////////////////////////////////
4706void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4707//////////////////////////////////////////
4708// Method Generating Ladder Support Ring
4709//////////////////////////////////////////
4710 if(!fCreateMaterials) CreateMaterials();
4711 if(!fTransformationMatrices) CreateTransformationMatrices();
4712 if(!fBasicObjects) CreateBasicObjects();
4713 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4714 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4715 const Int_t kssdlayladdernumber[fgklayernumber] =
4716 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4717 Double_t mountingsupportedge[fgklayernumber];
4718 Double_t mountingblockratio[fgklayernumber];
4719 Double_t theta[fgklayernumber];
4720 Double_t phi[fgklayernumber];
4721 for(Int_t i=0; i<fgklayernumber; i++){
4722 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4723 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4724 *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4725 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4726 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4727 / kssdlayladdernumber[i])));
4728 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4729 / fgkMountingBlockSupportRadius[i]);
4730 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4731 }
4732 TGeoRotation* globalrot = new TGeoRotation();
4733 globalrot->SetAngles(0.,-90.,0.);
4734 TGeoRotation** laddersupportrot[fgklayernumber];
4735 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4736 for(Int_t i=0; i<fgklayernumber; i++){
4737 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4738 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4739 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4740 laddersupportrot[i][j] = new TGeoRotation();
4741 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4742 switch(i){
4743 case 0: //Ladder of Layer5
4744 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4745 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4746 laddersupportmatrix[i][j]);
4747 break;
4748 case 1: //Ladder of Layer6
4749 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4750 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4751 laddersupportmatrix[i][j]);
4752 break;
4753 }
4754 }
4755 }
4756 /////////////////////////////////////////////////////////////
4757 // Creating Lower Ladder Support
4758 /////////////////////////////////////////////////////////////
4759 TVector3** ringsupportvertex[fgklayernumber];
4760 Double_t angle = 360./nedges;
4761 for(Int_t i=0; i<fgklayernumber; i++){
4762 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4763 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4764 * TMath::Cos(theta[i]));
4765 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4766 - mountingsupportedge[i],
4767 ringsupportvertex[i][0]->Y());
4768 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4769 ringsupportvertex[i][1]->Y());
4770 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4771 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4772 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4773 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4774 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4775 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4776 }
4777 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4778 for(Int_t j=0; j<nedges+1; j++){
4779 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
cd2243fb 4780 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
4781 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle));
9b0c60ab 4782 }
4783 }
4784 Double_t **xmothervertex = new Double_t*[fgklayernumber];
4785 Double_t **ymothervertex = new Double_t*[fgklayernumber];
4786 for(Int_t i=0; i<fgklayernumber; i++){
4787 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4788 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4789 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4790 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4791 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4792 }
4793 }
0e8760e5 4794////////////////////////////////////////////////////////////////////////////////
4795// Start Corrections 13/06/08
4796////////////////////////////////////////////////////////////////////////////////
a3f8715e 4797 char lowerladderpconsupportname[100];
0e8760e5 4798 TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4799 TGeoVolume* lowerladderpconsupport[fgklayernumber];
4800 Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4801 Double_t lowerladderpconradiusmax[fgklayernumber];
4802 Double_t lowerladderpconradiusmin[fgklayernumber];
4803 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4804 lowerladdersupportrot->SetAngles(90.,180.,-90);
4805 for(Int_t i=0; i<fgklayernumber; i++){
4806 lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4807 * TMath::Cos(theta[i]);
cd2243fb 4808 lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
0e8760e5 4809 }
4810 for(Int_t i=0; i<fgklayernumber; i++){
4811/////////////////////////// Modified Version ?///////////////////
4812 lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4813 for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
4814 lowerladderpconezsection[j],lowerladderpconradiusmin[i],
4815 lowerladderpconradiusmax[i]);
045be90c 4816 snprintf(lowerladderpconsupportname,100,"LowerLadderPConSupportNameLay%d",i+5);
0e8760e5 4817 lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
4818 lowerladderpconsupport[i]->SetLineColor(fColorAl);
4819 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
4820 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
4821 }
4822////////////////////////////////////////////////////////////////////////////////
4823// End Corrections 13/06/08
4824////////////////////////////////////////////////////////////////////////////////
4825 /*char lowerladdersupportname[30];
9b0c60ab 4826 TGeoXtru* lowerladdersupportshape[fgklayernumber];
4827 TGeoVolume* lowerladdersupport[fgklayernumber];
4828 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4829 lowerladdersupportrot->SetAngles(90.,180.,-90);
4830 for(Int_t i=0; i<fgklayernumber; i++){
4831 lowerladdersupportshape[i] = new TGeoXtru(2);
4832 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
4833 xmothervertex[i],ymothervertex[i]);
4834 lowerladdersupportshape[i]->DefineSection(0,0.);
4835 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4836 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
4837 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
4838 lowerladdersupportshape[i],fSSDSupportRingAl);
4839 lowerladdersupport[i]->SetLineColor(fColorAl);
4840 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
4841 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
0e8760e5 4842 }*/
9b0c60ab 4843 /////////////////////////////////////////////////////////////
4844 // Deallocating memory
4845 /////////////////////////////////////////////////////////////
4846 for(Int_t i=0; i<fgklayernumber; i++){
4847 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
4848 delete ringsupportvertex[i][j];
4849 delete [] ringsupportvertex[i];
4850 }
4851 for(Int_t i=0; i<fgklayernumber; i++){
4852 delete [] xmothervertex[i];
4853 delete [] ymothervertex[i];
4854 }
7b208ef4 4855 delete [] xmothervertex;
4856 delete [] ymothervertex;
9b0c60ab 4857 delete globalrot;
4858 for(Int_t i=0; i<fgklayernumber; i++){
4859 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
4860 delete laddersupportrot[i][j];
4861 delete [] laddersupportrot[i];
4862 }
4863 }
4864 ////////////////////////////////////////////////////////////////////////////////
4865 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
4866 /////////////////////////////////////////////////////////////
4867 // Method generating Endcap CoverPlate
4868 /////////////////////////////////////////////////////////////
4869 // Holes Definition
4870 ///////////////////
4871 Int_t nendcapcoverplateholedges = 30;
4872 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
4873 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
4874 0.5*fgkEndCapCoverPlateThickness};
851c0ce3 4875 TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
9b0c60ab 4876 nendcapcoverplateholedges,holesection);
4877 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 4878 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4879 endcapcoverplatesmallhole->SetLineColor(6);
851c0ce3 4880 TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
9b0c60ab 4881 nendcapcoverplateholedges,holesection);
4882 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 4883 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4884 endcapcoverplatebighole->SetLineColor(6);
4885 //////////////////////////
4886 // Screw Piece Definition
4887 //////////////////////////
4888 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
4889 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
4890 CosD(0.5*smallscrewangle),
4891 0.5*fgkEndCapCoverPlateThickness);
4892 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
4893 endcapsmallscrewpieceshape,
4894 fSSDCoolingTubePhynox);
4895 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
4896 ///////////////////
4897 // Box Definition
4898 ///////////////////
4899 TGeoBBox* endcapcoverplateboxshape[4];
4900 TGeoVolume* endcapcoverplatebox[4];
4901 Double_t boxorigin[5][3];
4902 boxorigin[0][0] = 0.;
4903 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
4904 boxorigin[0][2] = 0.;
4905
4906 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
4907 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
4908 boxorigin[1][2] = 0.;
4909
4910 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
4911 + fgkEndCapCoverPlateSmallHoleSeparation[1];
4912 boxorigin[2][1] = boxorigin[1][1];
4913 boxorigin[2][2] = 0.;
4914
4915 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
4916 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
4917 boxorigin[3][1] = boxorigin[1][1];
4918 boxorigin[3][2] = 0.;
4919
4920 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4921 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
4922 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
4923 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
4924
4925 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4926 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4927 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4928 + fgkEndCapCoverPlateSmallHoleRadius,
4929 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
4930
4931 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4932 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4933 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4934 + fgkEndCapCoverPlateSmallHoleRadius,
4935 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
4936
4937 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
4938 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4939 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4940 + fgkEndCapCoverPlateSmallHoleRadius,
4941 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
4942
4943 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 4944 fSSDAlCoolBlockMedium);
9b0c60ab 4945 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 4946 fSSDAlCoolBlockMedium);
9b0c60ab 4947 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 4948 fSSDAlCoolBlockMedium);
9b0c60ab 4949 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 4950 fSSDAlCoolBlockMedium);
9b0c60ab 4951 endcapcoverplatebox[0]->SetLineColor(6);
4952 endcapcoverplatebox[1]->SetLineColor(6);
4953 endcapcoverplatebox[2]->SetLineColor(6);
4954 endcapcoverplatebox[3]->SetLineColor(6);
4955 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
4956 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4957 fgkEndCapCoverPlateSmallHoleRadius,
4958 0.5*fgkEndCapCoverPlateThickness,
4959 endcapfillingboxorigin);
4960 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 4961 fSSDAlCoolBlockMedium);
9b0c60ab 4962 endcapfillingbox->SetLineColor(6);
4963 ////////////////////////////
851c0ce3 4964 // Contour shape Definition
9b0c60ab 4965 ////////////////////////////
4966 const Int_t kcontourvertexnumber = 10;
4967 Double_t xcontourvertex[kcontourvertexnumber];
4968 Double_t ycontourvertex[kcontourvertexnumber];
4969 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
4970 xcontourvertex[1] = xcontourvertex[0];
4971 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4972 xcontourvertex[3] = xcontourvertex[2];
4973 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
4974 xcontourvertex[5] = xcontourvertex[4];
4975 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4976 xcontourvertex[7] = xcontourvertex[6];
4977 xcontourvertex[8] = xcontourvertex[4];
4978 xcontourvertex[9] = xcontourvertex[8];
4979 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4980 - (kendcapcoverplatesmallholenumber[1]-1)
4981 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4982 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
4983 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4984 ycontourvertex[2] = ycontourvertex[1];
4985 ycontourvertex[3] = ycontourvertex[0];
4986 ycontourvertex[4] = ycontourvertex[3];
4987 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
4988 ycontourvertex[6] = ycontourvertex[5];
4989 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
4990 * fgkEndCapCoverPlateSmallHoleSeparation[2]
4991 + fgkEndCapCoverPlateSmallHoleRadius;
4992 ycontourvertex[8] = ycontourvertex[7];
4993 ycontourvertex[9] = ycontourvertex[0];
851c0ce3 4994
4995 Double_t xboxin, dxboxin, yboxin, dyboxin;
4996 Double_t xboxout, dxboxout, yboxout, dyboxout;
4997 Double_t coordmin, coordmax;
4998 coordmin = -fgkEndCapCoverPlateLength[0];
4999 coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5000 xboxout = 0.5*(coordmin+coordmax);
5001 dxboxout = 0.5*(coordmax-coordmin);
5002 coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5003 - (kendcapcoverplatesmallholenumber[1]-1)
5004 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5005 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5006 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5007 yboxout = 0.5*(coordmin+coordmax);
5008 dyboxout = 0.5*(coordmax-coordmin);
5009 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5010 coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5011 xboxin = 0.5*(coordmin+coordmax);
5012 dxboxin = 0.5*(coordmax-coordmin);
5013 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5014 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5015 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5016 + fgkEndCapCoverPlateSmallHoleRadius;
5017 yboxin = 0.5*(coordmin+coordmax);
5018 dyboxin = 0.5*(coordmax-coordmin);
5019 new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5020 TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5021 xboxout, yboxout, 0.);
5022 trendCapCoverPlateContourboxout->RegisterYourself();
5023 new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5024 TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5025 xboxin, yboxin, 0.);
5026 trendCapCoverPlateContourboxin->RegisterYourself();
5027 TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5028 "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5029
e21cdd03 5030 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5031 fSSDAlCoolBlockMedium);
9b0c60ab 5032 contour->SetLineColor(6);
5033 /////////////////////////////
851c0ce3 5034 // Hole Contour Shape Definition
9b0c60ab 5035 ////////////////////////////
851c0ce3 5036 coordmin = xcontourvertex[0];
5037 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5038 xboxout = 0.5*(coordmin+coordmax);
5039 dxboxout = 0.5*(coordmax-coordmin);
5040 coordmin = ycontourvertex[1];
5041 coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5042 yboxout = 0.5*(coordmin+coordmax);
5043 dyboxout = 0.5*(coordmax-coordmin);
5044 coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5045 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5046 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5047 xboxin = 0.5*(coordmin+coordmax);
5048 dxboxin = 0.5*(coordmax-coordmin);
5049 coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5050 - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5051 coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5052 yboxin = 0.5*(coordmin+coordmax);
5053 dyboxin = 0.5*(coordmax-coordmin);
5054 new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5055 TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5056 xboxout, yboxout, 0.);
5057 trendCapCoverPlateContourboxout1->RegisterYourself();
5058 new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5059 TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5060 xboxin, yboxin, 0.);
5061 trendCapCoverPlateContourboxin1->RegisterYourself();
5062 TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5063 "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5064
5065
5066 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5067 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5068 xboxout = 0.5*(coordmin+coordmax);
5069 dxboxout = 0.5*(coordmax-coordmin);
5070 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5071 - fgkEndCapCoverPlateWidth[0]);
5072 coordmax = ycontourvertex[0];
5073 yboxout = 0.5*(coordmin+coordmax);
5074 dyboxout = 0.5*(coordmax-coordmin);
5075 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5076 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5077 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5078 xboxin = 0.5*(coordmin+coordmax);
5079 dxboxin = 0.5*(coordmax-coordmin);
5080 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5081 - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5082 - fgkEndCapCoverPlateWidth[0]
5083 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5084 coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5085 yboxin = 0.5*(coordmin+coordmax);
5086 dyboxin = 0.5*(coordmax-coordmin);
5087 new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5088 TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5089 xboxout, yboxout, 0.);
5090 trendCapCoverPlateContourboxout2->RegisterYourself();
5091 new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5092 TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5093 xboxin, yboxin, 0.);
5094 trendCapCoverPlateContourboxin2->RegisterYourself();
5095 TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5096 "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5097
5098// const Int_t kholecontourvertexnumber = 10;
5099
9b0c60ab 5100 Double_t xholecontourvertex[2][kcontourvertexnumber];
5101 Double_t yholecontourvertex[2][kcontourvertexnumber];
5102 xholecontourvertex[0][0] = xcontourvertex[0];
5103 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5104 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5105 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5106 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5107 + 0.5*(fgkEndCapCoverPlateLength[2]
5108 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5109 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5110 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5111 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5112 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5113 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5114 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5115
5116 yholecontourvertex[0][0] = ycontourvertex[1];
5117 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5118 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5119 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5120 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5121 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5122 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5123 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5124 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5125 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5126 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5127
5128 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5129 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5130 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5131 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5132 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5133 + 0.5*(fgkEndCapCoverPlateLength[2]
5134 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5135 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5136 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5137 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5138 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5139 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5140 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5141
5142 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5143 - fgkEndCapCoverPlateWidth[0]);
5144 yholecontourvertex[1][1] = ycontourvertex[0];
5145 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5146 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5147 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5148 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5149 - fgkEndCapCoverPlateWidth[0]
5150 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5151 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5152 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5153 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5154 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5155
9b0c60ab 5156 TGeoVolume* holecontour[2];
851c0ce3 5157 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
e21cdd03 5158 fSSDAlCoolBlockMedium);
9b0c60ab 5159 holecontour[0]->SetLineColor(6);
851c0ce3 5160 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
e21cdd03 5161 fSSDAlCoolBlockMedium);
9b0c60ab 5162 holecontour[1]->SetLineColor(6);
5163 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5164 + fgkEndCapCoverPlateLength[2],0.,0.);
5165 TGeoTranslation* bigholetrans[3];
5166 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5167 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5168 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5169 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5170 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5171 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5172 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5173 /////////////////////////////////
5174 // Mother Volume Xtru Definition
5175 /////////////////////////////////
5176 const Int_t kmothervertexnumber = 12;
5177 Double_t xmothervertex[kmothervertexnumber];
5178 Double_t ymothervertex[kmothervertexnumber];
5179 xmothervertex[0] = xcontourvertex[0];
5180 xmothervertex[1] = xmothervertex[0];
5181 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5182 xmothervertex[3] = xmothervertex[2];
5183 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5184 xmothervertex[5] = xmothervertex[4];
5185 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5186 xmothervertex[7] = xmothervertex[6];
5187 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5188 + fgkEndCapCoverPlateLength[2];
5189 xmothervertex[9] = xmothervertex[8];
5190 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5191 xmothervertex[11] = xmothervertex[10];
5192
5193 ymothervertex[0] = ycontourvertex[0];
5194 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5195 ymothervertex[2] = ymothervertex[1];
5196 ymothervertex[3] = ycontourvertex[1];
5197 ymothervertex[4] = ymothervertex[3];
5198 ymothervertex[5] = ymothervertex[1];
5199 ymothervertex[6] = ymothervertex[5];
5200 ymothervertex[7] = ymothervertex[0];
5201 ymothervertex[8] = ymothervertex[7];
5202 ymothervertex[9] = ymothervertex[8]
5203 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5204 ymothervertex[10] = ymothervertex[9];
5205 ymothervertex[11] = ymothervertex[8];
5206 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5207 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5208 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5209 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5210 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5211 ////////////////////////////////////////
5212 // Adding Nodes
5213 ////////////////////////////////////////
5214// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5215 TGeoTranslation*** endcapcoverplatesmallholetrans;
5216 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5217 Double_t transx[4] = {0,
5218 fgkEndCapCoverPlateSmallHoleSeparation[0],
5219 fgkEndCapCoverPlateSmallHoleSeparation[0]
5220 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5221 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5222 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5223 Int_t index = 0;
5224 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5225 endcapcoverplatesmallholetrans[i] =
5226 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5227 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5228 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5229 endcapcoverplatesmallholetrans[i][j] =
5230 new TGeoTranslation(transx[i],
5231 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5232 if(index!=10){
5233 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5234 index,endcapcoverplatesmallholetrans[i][j]);
5235 mothercoverplate->AddNode(endcapsmallscrewpiece,
5236 index,endcapcoverplatesmallholetrans[i][j]);
5237 }
5238 if(j<kendcapcoverplatesmallholenumber[1]-1)
5239 mothercoverplate->AddNode(endcapcoverplatebox[0],
5240 index,endcapcoverplatesmallholetrans[i][j]);
5241 }
5242 }
5243 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5244 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5245 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5246 mothercoverplate->AddNode(endcapfillingbox,1);
5247 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5248 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5249 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5250 mothercoverplate->AddNode(holecontour[0],1);
5251 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5252 mothercoverplate->AddNode(holecontour[1],1);
5253 mothercoverplate->AddNode(contour,1);
045be90c 5254
5255 for (Int_t i = 0; i < kendcapcoverplatesmallholenumber[0]; i++)
5256 delete [] endcapcoverplatesmallholetrans[i];
5257 delete [] endcapcoverplatesmallholetrans;
9b0c60ab 5258 /////////////////////////////////
5259 return mothercoverplate;
5260 }
5261 ////////////////////////////////////////////////////////////////////////////////
5262 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5263 /////////////////////////////////////////////////////////////
5264 // Getting EndCap Cooling Tube
5265 /////////////////////////////////////////////////////////////
5266 TGeoTorus* endcapcoolingtubetorushape[5];
5267 TGeoVolume* endcapcoolingtubetorus[5];
5268 TGeoTube* endcapcoolingtubeshape[4];
5269 TGeoVolume* endcapcoolingtube[4];
a3f8715e 5270 char endcapcoolingtubetorusname[100];
5271 char endcapcoolingtubename[100];
9b0c60ab 5272 TGeoTorus* endcapcoolingwatertubetorushape[5];
5273 TGeoVolume* endcapcoolingwatertubetorus[5];
5274 TGeoTube* endcapcoolingwatertubeshape[4];
5275 TGeoVolume* endcapcoolingwatertube[4];
a3f8715e 5276 char endcapcoolingwatertubetorusname[100];
5277 char endcapcoolingwatertubename[100];
9b0c60ab 5278 for(Int_t i=0; i<5; i++){
045be90c 5279 snprintf(endcapcoolingtubetorusname,100,"EndCapCoolingTubeTorus%d",i+1);
5280 snprintf(endcapcoolingtubename,100,"EndCapCoolingTube%d",i+1);
5281 snprintf(endcapcoolingwatertubetorusname,100,"EndCapCoolingWaterTubeTorus%d",i+1);
5282 snprintf(endcapcoolingwatertubename,100,"EndCapCoolingWaterTube%d",i+1);
5283 if(i==3){
5284 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5285 fgkEndCapCoolingTubeRadiusMin,
5286 fgkEndCapCoolingTubeRadiusMax,
5287 90.0,fgkEndCapCoolingTubeAngle[3]);
5288 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5289 0.,fgkEndCapCoolingTubeRadiusMin,
5290 90.0,fgkEndCapCoolingTubeAngle[3]);
5291 }
5292 else{
5293 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5294 :fgkEndCapCoolingTubeAxialRadius[1],
5295 fgkEndCapCoolingTubeRadiusMin,
5296 fgkEndCapCoolingTubeRadiusMax,
5297 0.,fgkEndCapCoolingTubeAngle[i]);
5298 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5299 :fgkEndCapCoolingTubeAxialRadius[1],
5300 0.,fgkEndCapCoolingTubeRadiusMin,
5301 0.,fgkEndCapCoolingTubeAngle[i]);
9b0c60ab 5302 }
9b0c60ab 5303 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5304 endcapcoolingtubetorushape[i],
5305 fSSDCoolingTubePhynox);
5306 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5307 endcapcoolingwatertubetorushape[i],
5308 fSSDCoolingTubeWater);
5309 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5310 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5311 if(i<4){
5312 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5313 fgkEndCapCoolingTubeRadiusMax,
5314 0.5*fgkEndCapCoolingTubeLength[i]);
5315 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5316 0.5*fgkEndCapCoolingTubeLength[i]);
5317 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5318 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5319 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5320 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5321 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5322 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5323 }
5324 }
5325 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5326 /////////////////////////////////////////
5327 // Transformation for Volume Positioning
5328 /////////////////////////////////////////
5329 TGeoCombiTrans* coolingtubecombitrans[6];
5330 TGeoRotation* coolingtuberot[8];
5331 TGeoTranslation* coolingtubetrans[6];
5332 TGeoHMatrix* coolingtubematrix[4];
5333 TGeoCombiTrans* torustubecombitrans[4];
5334 TGeoRotation* torustuberot[7];
5335 TGeoTranslation* torustubetrans[4];
5336 TGeoHMatrix* torustubematrix[5];
5337 TGeoCombiTrans* coolingwatertubecombitrans[6];
5338 TGeoRotation* coolingwatertuberot[8];
5339 TGeoTranslation* coolingwatertubetrans[6];
5340 TGeoHMatrix* coolingwatertubematrix[4];
5341 TGeoCombiTrans* toruswatertubecombitrans[4];
5342 TGeoRotation* toruswatertuberot[7];
5343 TGeoTranslation* toruswatertubetrans[4];
5344 TGeoHMatrix* toruswatertubematrix[5];
5345 for(Int_t i=0; i<8; i++){
5346 if(i<6){
5347 coolingtubetrans[i] = new TGeoTranslation();
5348 coolingwatertubetrans[i] = new TGeoTranslation();
5349 }
5350 if(i<8){
5351 coolingtuberot[i] = new TGeoRotation();
5352 coolingwatertuberot[i] = new TGeoRotation();
5353 }
5354 if(i<4){
5355 torustubetrans[i] = new TGeoTranslation();
5356 toruswatertubetrans[i] = new TGeoTranslation();
5357 }
5358 if(i<7){
5359 torustuberot[i] = new TGeoRotation();
5360 toruswatertuberot[i] = new TGeoRotation();
5361 }
5362 }
5363 /////////////////////////////////////////
5364 // Transformation for Inox Volume Positioning
5365 /////////////////////////////////////////
5366 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5367 -endcapcoolingtubeshape[0]->GetDz(),0.);
5368 coolingtuberot[0]->SetAngles(0.,90.,0.);
5369 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5370 *coolingtuberot[0]);
5371
5372 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5373 coolingtuberot[1]->SetAngles(0.,90.,0.);
5374 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5375 *coolingtuberot[1]);
5376
5377 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5378 *CosD(fgkEndCapCoolingTubeAngle[0]),
5379 fgkEndCapCoolingTubeAxialRadius[0]
5380 *SinD(fgkEndCapCoolingTubeAngle[0]),
5381 0.);
5382 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5383 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5384 *coolingtuberot[2]);
5385
5386 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5387 * (*coolingtubecombitrans[1]));
5388
5389 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5390 endcapcoolingtubeshape[1]->GetDz());
5391 torustuberot[0]->SetAngles(0.,90.,0.);
5392 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5393
5394 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5395
5396 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5397 -endcapcoolingtubeshape[2]->GetDz(),0.);
5398 coolingtuberot[3]->SetAngles(0.,90.,0.);
5399 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5400 *coolingtuberot[3]);
5401 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5402 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5403 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5404
5405 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5406 endcapcoolingtubeshape[2]->GetDz());
5407 torustuberot[1]->SetAngles(0.,90.,0.);
5408 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5409 torustuberot[2]->SetAngles(180.,0.,0.);
5410 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5411 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5412
5413 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5414 -fgkEndCapCoolingTubeAxialRadius[0]);
5415 torustuberot[3]->SetAngles(0.,90.,0.);
5416 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5417 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5418 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5419 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5420
5421 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5422 fgkEndCapCoolingTubeAxialRadius[0],0.);
5423 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5424 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5425 *coolingtuberot[5]);
5426 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5427 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5428 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5429
5430 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5431 endcapcoolingtubeshape[0]->GetDz());
5432 torustuberot[5]->SetAngles(0.,90.,0.);
5433 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5434 torustuberot[6]->SetAngles(-90.,0.,0.);
5435 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5436 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5437
5438 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5439 endcapcoolingtubeshape[3]->GetDz(),0.);
5440 coolingtuberot[6]->SetAngles(0.,90.,0.);
5441 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5442 *coolingtuberot[6]);
5443 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5444 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5445 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5446 /////////////////////////////////////////
5447 // Transformation for Water Volume Positioning
5448 /////////////////////////////////////////
5449 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5450 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5451 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5452 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5453 *coolingwatertuberot[0]);
5454
5455 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5456 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5457 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5458 *coolingwatertuberot[1]);
5459
5460 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5461 *CosD(fgkEndCapCoolingTubeAngle[0]),
5462 fgkEndCapCoolingTubeAxialRadius[0]
5463 *SinD(fgkEndCapCoolingTubeAngle[0]),
5464 0.);
5465 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5466 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5467 *coolingwatertuberot[2]);
5468
5469 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5470 * (*coolingwatertubecombitrans[1]));
5471
5472 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5473 endcapcoolingwatertubeshape[1]->GetDz());
5474 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5475 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5476 *toruswatertuberot[0]);
5477
5478 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5479 * (*toruswatertubecombitrans[0]));
5480
5481 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5482 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5483 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5484 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5485 *coolingwatertuberot[3]);
5486 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5487 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5488 * (*coolingwatertubecombitrans[3]));
5489 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5490
5491 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5492 endcapcoolingwatertubeshape[2]->GetDz());
5493 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5494 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5495 *toruswatertuberot[1]);
5496 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5497 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5498 * (*toruswatertubecombitrans[1]));
5499 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5500
5501 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5502 -fgkEndCapCoolingTubeAxialRadius[0]);
5503 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5504 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5505 *toruswatertuberot[3]);
5506 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5507 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5508 * (*toruswatertubecombitrans[2]));
5509 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5510
5511 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5512 fgkEndCapCoolingTubeAxialRadius[0],0.);
5513 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5514 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5515 *coolingwatertuberot[5]);
5516 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5517 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5518 * (*coolingwatertubecombitrans[4]));
5519 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5520
5521 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5522 endcapcoolingwatertubeshape[0]->GetDz());
5523 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5524 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5525 *toruswatertuberot[5]);
5526 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5527 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5528 * (*toruswatertubecombitrans[3]));
5529 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5530
5531 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5532 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5533 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5534 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5535 *coolingwatertuberot[6]);
5536 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5537 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5538 * (*coolingwatertubecombitrans[5]));
5539 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5540 /////////////////////////////////////////
5541 // Positioning Volumes
5542 /////////////////////////////////////////
5543 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5544 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5545
5546 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5547 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5548
5549 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5550 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5551
5552 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5553 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5554
5555 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5556 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5557
5558 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5559 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5560
5561 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5562 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5563
5564 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5565 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5566
5567 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5568 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5569
5570 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5571 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5572 /////////////////////////////////////////////////////////////
5573 // Deallocating memory
5574 /////////////////////////////////////////////////////////////
5575 for(Int_t i=0; i<8; i++){
5576 if(i<6){
5577 delete coolingtubetrans[i];
5578 delete coolingwatertubetrans[i];
5579 if(i!=0){
5580 delete coolingtubecombitrans[i];
5581 delete coolingwatertubecombitrans[i];
5582 }
5583 }
5584 if(i<8){
5585 delete coolingtuberot[i];
5586 delete coolingwatertuberot[i];
5587 }
5588 if(i<4){
5589 delete torustubetrans[i];
5590 delete toruswatertubetrans[i];
5591 delete torustubecombitrans[i];
5592 delete toruswatertubecombitrans[i];
5593 }
5594 if(i<7){
5595 delete torustuberot[i];
5596 delete toruswatertuberot[i];
5597 }
5598 }
5599 /////////////////////////////////////////////////////////////
5600 return endcapcoolingtubemother;
5601 }
5602 ////////////////////////////////////////////////////////////////////////////////
5603 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5604 /////////////////////////////////////////////////////////////
5605 // Getting EndCap Cover Side
5606 /////////////////////////////////////////////////////////////
5607 const Int_t kendcapcoverholenumber[2] = {7,5};
5608 const Int_t kvertexnumber = 15;
5609 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5610 xvertex[0] = 0.0;
5611 xvertex[1] = xvertex[0];
5612 xvertex[2] = fgkEndCapSideCoverLength[0];
5613 xvertex[3] = fgkEndCapSideCoverLength[1];
5614 xvertex[4] = xvertex[3];
5615 xvertex[5] = fgkEndCapSideCoverLength[2];
5616 xvertex[6] = xvertex[5];
5617 xvertex[7] = xvertex[2];
5618 xvertex[8] = xvertex[7];
5619 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5620 xvertex[10] = xvertex[9];
5621 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5622 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5623 * fgkEndCapSideCoverLength[4];
5624 xvertex[12] = xvertex[11];
5625 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5626 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5627 * fgkEndCapSideCoverLength[4];
5628 xvertex[14] = xvertex[13];
5629 yvertex[0] = 0.0;
5630 yvertex[1] = fgkEndCapSideCoverWidth[0];
5631 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5632 yvertex[3] = yvertex[2];
5633 yvertex[4] = fgkEndCapSideCoverWidth[1];
5634 yvertex[5] = yvertex[4];
5635 yvertex[6] = yvertex[0];
5636 yvertex[7] = yvertex[6];
5637 yvertex[8] = fgkEndCapSideCoverWidth[6];
5638 yvertex[9] = yvertex[8];
5639 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5640 yvertex[11] = yvertex[10];
5641 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5642 yvertex[13] = yvertex[12];
5643 yvertex[14] = yvertex[6];
851c0ce3 5644 TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5645 endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5646 endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5647 endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5648 endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5649 TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5650 endcapsidecovershapein->SetName("endcapsidecovershapein");
5651 endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5652 endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5653 endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5654
5655
5656 TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
9b0c60ab 5657 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5658 endcapsidecovershape,fSSDCoolingTubePhynox);
5659 endcapsidecover->SetLineColor(fColorPhynox);
5660 ////////////////////////////////////////////
5661 // Defininition of Mother Volume
5662 ////////////////////////////////////////////
5663 const Int_t kmothervertexnumber = 7;
5664 Double_t xmothervertex[kmothervertexnumber];
5665 Double_t ymothervertex[kmothervertexnumber];
5666 for(Int_t i=0; i<kmothervertexnumber; i++){
5667 xmothervertex[i] = xvertex[i];
5668 ymothervertex[i] = yvertex[i];
5669 }
5670 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5671 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5672 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5673 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5674 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5675 endcapsidecovermothershape,fSSDAir);
5676 ////////////////////////////////////////////
5677 endcapsidecovermother->AddNode(endcapsidecover,1);
5678 TGeoBBox* endcapsidecoverboxshape[4];
5679 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5680 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5681 0.5*fgkEndCapSideCoverLength[4],
5682 0.5*fgkEndCapSideCoverThickness);
5683 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5684 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5685 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5686 - fgkEndCapSideCoverLength[4]),
5687 0.5*fgkEndCapSideCoverThickness);
5688 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5689 0.5*fgkEndCapSideCoverLength[4],
5690 0.5*fgkEndCapSideCoverThickness);
5691 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5692 0.5*fgkEndCapSideCoverWidth[5],
5693 0.5*fgkEndCapSideCoverThickness);
5694 TGeoVolume* endcapsidecoverbox[4];
5695 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5696 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5697 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5698 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5699 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5700// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5701 TGeoTranslation** endcapsidecoverboxtrans;
5702 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5703 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5704 + fgkEndCapSideCoverLength[0],
5705 endcapsidecoverboxshape[0]->GetDY()
5706 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5707 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5708 + xvertex[11],
5709 endcapsidecoverboxshape[1]->GetDY()
5710 + yvertex[12],0.);
5711 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5712 + xvertex[11],
5713 endcapsidecoverboxshape[2]->GetDY()
5714 + yvertex[12]
5715 + 2.*endcapsidecoverboxshape[1]->GetDY()
5716 + fgkEndCapSideCoverWidth[5],0.);
5717 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5718 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5719 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5720 for(Int_t i=0; i<2; i++)
5721 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5722 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5723 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5724 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5725 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5726 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5727 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5728 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5729 }
5730 for(Int_t i=0; i<2; i++)
5731 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5732 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5733 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5734 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5735 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5736 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5737 +fgkEndCapSideCoverLength[4]),0.0);
5738 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5739 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5740 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5741 +i*(kendcapcoverholenumber[1]-1)+j]);
5742 }
b7bd9ab6 5743 delete [] endcapsidecoverboxtrans;
5744 return endcapsidecovermother;
9b0c60ab 5745 }
5746 ////////////////////////////////////////////////////////////////////////////////
5747 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5748 ////////////////////////////////////////////////////////////////////////////////
5749 // Method returning Interface Card A, Interface Card B, Supply Card
5750 ////////////////////////////////////////////////////////////////////////////////
5751 /////////////////////
5752 // Supply Card
5753 /////////////////////
5754 // Electronic Board Back Al Plane
5755 const Int_t kelectboardbackvertexnumber = 8;
5756 Double_t xelectboardback[kelectboardbackvertexnumber];
5757 Double_t yelectboardback[kelectboardbackvertexnumber];
5758 xelectboardback[0] = 0.0;
5759 xelectboardback[1] = xelectboardback[0];
5760 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5761 xelectboardback[3] = xelectboardback[2];
5762 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5763 xelectboardback[5] = xelectboardback[4];
5764 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5765 xelectboardback[7] = xelectboardback[6];
5766
5767 yelectboardback[0] = 0.0;
5768 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5769 yelectboardback[2] = yelectboardback[1];
5770 yelectboardback[3] = yelectboardback[0];
5771 yelectboardback[4] = yelectboardback[3];
5772 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5773 yelectboardback[6] = yelectboardback[5];
5774 yelectboardback[7] = yelectboardback[4];
5775 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5776 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5777 xelectboardback,yelectboardback);
5778 electboardbackshape->DefineSection(0,0.0);
5779 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5780 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5781 electboardbackshape,fSSDSupportRingAl);
5782 electboardback->SetLineColor(fColorAl);
5783 // Electronic Board Kapton Layer
5784 const Int_t kelectlayervertexnumber = 8;
5785 Double_t xelectlayer[kelectlayervertexnumber];
5786 Double_t yelectlayer[kelectlayervertexnumber];
5787 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5788 xelectlayer[1] = xelectlayer[0];
5789 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5790 xelectlayer[3] = xelectlayer[2];
5791 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5792
5793 yelectlayer[0] = 0.0;
5794 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5795 yelectlayer[2] = yelectlayer[1];
5796 yelectlayer[3] = yelectlayer[0];
5797 yelectlayer[4] = yelectlayer[3];
5798 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5799 yelectlayer[6] = yelectlayer[5];
5800 yelectlayer[7] = yelectlayer[4];
5801 TGeoXtru* electlayershape = new TGeoXtru(2);
5802 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5803 electlayershape->DefineSection(0,0.0);
5804 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5805 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5806 electlayershape,fSSDKaptonFlexMedium);
5807 electlayer->SetLineColor(fColorKapton);
5808 // JMD Connector Female
5809 const Int_t kjmdconnectorvertexnumber = 6;
5810 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5811 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5812 xjmdconnectorvertex[0] = 0.0;
5813 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5814 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5815 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5816 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5817 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5818
5819 yjmdconnectorvertex[0] = 0.0;
5820 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5821 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5822 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5823 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5824 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5825 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5826 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5827 yjmdconnectorvertex);
5828 jmdconnectorshape->DefineSection(0,0.0);
5829 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5830 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5831 jmdconnectorshape,fSSDMountingBlockMedium);
5832 jmdconnector->SetLineColor(fColorG10);
5833 // Top Cable Connector
5834 const Int_t kcableconnectorvertexnumber = 8;
5835 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5836 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5837 xconnectorvertex[0] = 0.0;
5838 xconnectorvertex[1] = xconnectorvertex[0];
5839 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5840 xconnectorvertex[3] = xconnectorvertex[2];
5841 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5842 - fgkEndCapCardCableConnectorLength[2];
5843 xconnectorvertex[5] = xconnectorvertex[4];
5844 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5845 xconnectorvertex[7] = xconnectorvertex[6];
5846
5847 yconnectorvertex[0] = 0.0;
5848 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5849 yconnectorvertex[2] = yconnectorvertex[1];
5850 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5851 yconnectorvertex[4] = yconnectorvertex[3];
5852 yconnectorvertex[5] = yconnectorvertex[1];
5853 yconnectorvertex[6] = yconnectorvertex[5];
5854 yconnectorvertex[7] = yconnectorvertex[0];
5855 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5856 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5857 yconnectorvertex);
5858 cableconnectorshape->DefineSection(0,0.0);
5859 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5860 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5861 cableconnectorshape,fSSDMountingBlockMedium);
5862 cableconnector->SetLineColor(fColorG10);
5863 // Strip Connection
5864 TGeoBBox* endcapstripconnectionshape =
5865 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5866 0.5*fgkEndCapStripConnectionThickness,
5867 0.5*fgkEndCapStripConnectionWidth);
5868 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5869 endcapstripconnectionshape,
5870 fSSDSupportRingAl);
5871 endcapstripconnection->SetLineColor(fColorAl);
5872 // Interface Card B
5873 const Int_t kcardBvertexnumber = 12;
5874 Double_t xcardBvertexnumber[kcardBvertexnumber];
5875 Double_t ycardBvertexnumber[kcardBvertexnumber];
5876
5877 xcardBvertexnumber[0] = 0.0;
5878 xcardBvertexnumber[1] = xcardBvertexnumber[0];
5879 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5880 xcardBvertexnumber[3] = xcardBvertexnumber[2];
5881 xcardBvertexnumber[4] = xcardBvertexnumber[1];
5882 xcardBvertexnumber[5] = xcardBvertexnumber[4];
5883 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5884 xcardBvertexnumber[7] = xcardBvertexnumber[6];
5885 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5886 xcardBvertexnumber[9] = xcardBvertexnumber[8];
5887 xcardBvertexnumber[10] = xcardBvertexnumber[7];
5888 xcardBvertexnumber[11] = xcardBvertexnumber[10];
5889
5890 ycardBvertexnumber[0] = 0.0;
5891 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
5892 ycardBvertexnumber[2] = ycardBvertexnumber[1];
5893 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5894 ycardBvertexnumber[4] = ycardBvertexnumber[3];
5895 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5896 ycardBvertexnumber[6] = ycardBvertexnumber[5];
5897 ycardBvertexnumber[7] = ycardBvertexnumber[4];
5898 ycardBvertexnumber[8] = ycardBvertexnumber[7];
5899 ycardBvertexnumber[9] = ycardBvertexnumber[1];
5900 ycardBvertexnumber[10] = ycardBvertexnumber[9];
5901 ycardBvertexnumber[11] = ycardBvertexnumber[0];
5902
5903 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5904 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5905 interfacecardBshape->DefineSection(0,0.);
5906 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5907 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5908 fSSDMountingBlockMedium);
5909 interfacecardB->SetLineColor(46);
5910 // Interface Card B Electronic Board
5911 const Int_t kelectboardcardBvertexnumber = 14;
5912 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5913 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5914
5915 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5916 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
5917 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
5918 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
5919 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
5920 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
5921 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
5922 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
5923 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
5924 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
5925 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
5926 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
5927 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
5928 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
5929
5930 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
5931 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
5932 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
5933 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
5934 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
5935 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
5936 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
5937 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
5938 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
5939 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
5940 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
5941 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
5942 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
5943 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
5944
5945 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
5946 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
5947 xelectboardcardBvertex,yelectboardcardBvertex);
5948 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
5949 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
5950 + fgkEndCapInterfaceElectBoardCardBThickness);
5951 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
5952 fSSDSupportRingAl);
5953 electboardcardB->SetLineColor(fColorAl);
5954 // Generating Stiffener 2
5955 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
5956 0.5*fgkEndCapStiffenerThickness,
5957 0.5*fgkEndCapStiffenerLength);
5958 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
5959 endcapstiffener->SetLineColor(fColorAl);
5960 // Generating Mother Interface Card B Container
5961 const Int_t kinterfacecardBmothervertexnumber = 10;
5962 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5963 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5964
5965 xinterfacecardBmothervertex[0] = 0.0;
5966 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
5967 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
5968 + fgkEndCapInterfaceCardBThickness;
5969 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
5970 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
5971 + fgkEndCapInterfaceElectBoardCardBThickness;
5972 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
5973 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
5974 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
5975 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
5976 + fgkEndCapCardJMDConnectorLength[0];
5977 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
5978
5979 yinterfacecardBmothervertex[0] = 0.0;
5980 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
5981 + fgkEndCapInterfaceCardBWidth[1]
5982 + fgkEndCapInterfaceCardBWidth[2];
5983 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
5984 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
5985 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
5986 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
5987 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
5988 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
5989 + fgkEndCapCardJMDConnectorWidth[0]
5990 + fgkEndCapCardJMDConnectorWidth[1];
5991 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
5992 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
5993 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
5994 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
5995 xinterfacecardBmothervertex,
5996 yinterfacecardBmothervertex);
5997 interfacecardBmothershape->DefineSection(0,-1.e-15);
5998 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
5999 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6000 interfacecardBmothershape,fSSDAir);
6001 electboardcardB->SetLineColor(fColorAl);
6002 // Positioning Volumes Mother Interface Card B Container
6003 TGeoRotation* interfacecardBrot = new TGeoRotation();
6004 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6005 interfacecardBrot->SetAngles(90.,-90.,-90.);
6006 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6007 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6008 TGeoRotation* electboardcardBrot = new TGeoRotation();
6009 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6010 electboardcardBrot->SetAngles(90.,90.,-90.);
6011 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6012 TGeoCombiTrans* electboardcardBcombitrans =
6013 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6014 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6015 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6016 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6017 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6018 TGeoTranslation* jmdconnectorcardBtrans[3];
6019 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6020 for(Int_t i=0; i<3; i++){
6021 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6022 + fgkEndCapCardJMDConnectorLength[0],
6023 fgkEndCapCardElectBoardLayerWidth[1],
6024 0.5*fgkEndCapCardJMDConnectorThickness
6025 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6026 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6027 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6028 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6029 *jmdconnectorcardBrot);
6030 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6031 }
6032 // Mother Supply Card Container
6033 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6034 // Interface Card Container
6035 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6036 // Placing Volumes in Mother Supply Card Container
6037 // JMD Connector Positioning
6038 TGeoTranslation* jmdconnectortrans[2];
6039 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6040 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6041 fgkEndCapCardElectBoardBackLength[0]
6042 - fgkEndCapCardJMDConnectorThickness
6043 - fgkEndCapCardJMDConnectorToLayer);
6044 TGeoRotation* jmdconnectorot = new TGeoRotation();
6045 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6046 + 2.*fgkEndCapCardJMDConnectorLength[0]
6047 + 2.*fgkEndCapCardElectBoardLayerThickness,
6048 fgkEndCapCardElectBoardLayerWidth[1],
6049 fgkEndCapCardJMDConnectorThickness
6050 + fgkEndCapCardJMDConnectorToLayer);
6051 jmdconnectorot->SetAngles(90.,180.,-90);
6052 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6053 * jmdconnectorot);
6054 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6055 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6056 // Top Cable Connector Placing
6057 TGeoRotation* cableconnectorot[2];
6058 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6059 TGeoTranslation* cableconnectortrans[3];
6060 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6061 cableconnectorot[0]->SetAngles(90.,0.,0.);
6062 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6063 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6064 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6065 *cableconnectorot[0]);
6066 TGeoHMatrix* cableconnectormatrix[2];
6067 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6068 new TGeoHMatrix((*cableconnectorot[1])
6069 *(*cableconnectorcombitrans));
6070 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6071 - fgkEndCapCardCableConnectorThickness,
6072 fgkEndCapCardCableConnectorLength[0]
6073 + fgkEndCapCardCableConnectorToLayer);
6074 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6075 - 2.*fgkEndCapCardCableConnectorThickness
6076 - fgkEndCapCardCableConnectorDistance,
6077 fgkEndCapCardCableConnectorLength[0]
6078 + fgkEndCapCardCableConnectorToLayer);
6079 for(Int_t i=0; i<2; i++){
6080 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6081 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6082 }
6083 TGeoRotation* electboardbackrot = new TGeoRotation();
6084 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6085 electboardbackrot->SetAngles(90.,-90.,-90.);
6086 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6087 + fgkEndCapCardJMDConnectorLength[0]
6088 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6089 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6090 *electboardbackrot);
6091 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6092 // Electronic Board Kapton Layer Positioning
6093 TGeoRotation* electlayerrot = new TGeoRotation();
6094 TGeoTranslation* electlayertrans[2];
6095 TGeoCombiTrans* electlayercombitrans[2];
6096 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6097 electlayerrot->SetAngles(90.,-90.,-90.);
6098 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6099 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6100 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6101 + 2.*fgkEndCapCardElectBoardLayerThickness
6102 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6103 for(Int_t i=0; i<2; i++){
6104 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6105 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6106 }
6107 // Placing Volumes in Mother Interface Card Container
6108 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6109 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6110 for(Int_t i=0; i<2; i++){
6111 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6112 }
6113 /////////////////////////////////////////////////////////////
6114 // Generation of Card Interface Container
6115 /////////////////////////////////////////////////////////////
6116 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6117 - fgkEndCapCardJMDConnectorLength[0]
6118 - fgkEndCapInterfaceCardBThickness
6119 - 9.*fgkEndCapStripConnectionThickness
6120 - 8.*fgkEndCapCardElectBoardBackThickness;
6121 const Int_t kcardinterfacecontainervertexnumber = 14;
6122 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6123 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6124 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6125 - 7.0*fgkEndCapStripConnectionThickness;
6126 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6127 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6128 + fgkEndCapStripConnectionThickness
6129 - fgkEndCapCardElectBoardLayerThickness
6130 - fgkEndCapCardCableConnectorWidth[0];
6131 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6132 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6133 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6134 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6135 + 2.0*fgkEndCapStripConnectionThickness;
6136 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6137 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6138 + fgkEndCapInterfaceCardBThickness;
6139 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6140 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6141 + fgkEndCapInterfaceElectBoardCardBThickness;
6142 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6143 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6144 - fgkEndCapInterfaceElectBoardCardBThickness
6145 + fgkEndCapCardJMDConnectorLength[0]
6146 + stiffenertransx+fgkEndCapStiffenerWidth;
6147 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6148
6149 ycardinterfacecontainervertex[0] = 0.;
6150 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6151 + fgkEndCapCardJMDConnectorWidth[0]
6152 + fgkEndCapCardJMDConnectorWidth[1];
6153 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6154 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6155 - fgkEndCapStripConnectionWidth;
6156 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6157 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6158 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6159 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6160 + fgkEndCapInterfaceCardBWidth[1]
6161 + fgkEndCapInterfaceCardBWidth[2];
6162 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6163 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6164 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6165 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6166 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6167 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6168
6169 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6170 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6171 xcardinterfacecontainervertex,
6172 ycardinterfacecontainervertex);
6173 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6174 - fgkEndCapCardElectBoardBackLength[0]));
6175 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6176 + fgkEndCapCardElectBoardBackLength[0]));
6177 TGeoVolume** cardinterfacecontainer;
6178 cardinterfacecontainer = new TGeoVolume*[4];
6179 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6180 interfacecardmothershape,fSSDAir);
6181 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6182 interfacecardmothershape,fSSDAir);
6183 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6184 interfacecardmothershape,fSSDAir);
6185 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6186 interfacecardmothershape,fSSDAir);
6187 /////////////////////////////////
6188 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6189 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6190 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6191 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6192 /////////////////////////////////
6193 TGeoRotation* endcapstripconnectionrot[2];
6194 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6195 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6196 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6197 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6198 * (*endcapstripconnectionrot[0]));
6199 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6200 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6201 -0.5*fgkEndCapCardElectBoardBackThickness,
6202 fgkEndCapCardElectBoardBackWidth[0]
6203 -endcapstripconnectionshape->GetDZ(),
6204 0.5*fgkEndCapCardElectBoardBackLength[0]);
6205 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6206 TGeoTranslation* cardinterfacetrans[9];
6207 TGeoHMatrix* cardinterfacematrix[9];
6208 for(Int_t i=0; i<7; i++){
6209 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6210 + fgkEndCapCardElectBoardBackThickness),
6211 0.0,0.0);
6212 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6213 * (*endcapstripconnectionmatrix));
6214 }
6215 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6216 + fgkEndCapCardElectBoardBackThickness),
6217 0.0,0.0);
6218 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6219 * (*endcapstripconnectionmatrix));
6220 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6221 + fgkEndCapCardElectBoardBackThickness),
6222 0.0,0.0);
6223 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6224 * (*endcapstripconnectionmatrix));
6225
6226 for(Int_t i=0; i<4; i++){
6227 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6228 cardinterfacematrix[7]);
6229 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6230 cardinterfacematrix[8]);
6231 }
6232 TGeoTranslation* mothersupplycardtrans =
6233 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6234 + 2.*fgkEndCapCardJMDConnectorLength[0]
6235 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6236 TGeoHMatrix* mothersupplycardmatrix[7];
6237 Int_t index[4] = {1,1,1,1};
6238 for(Int_t i=0; i<7; i++){
6239 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6240 * (*mothersupplycardtrans));
6241 for(Int_t j=0; j<4; j++){
6242 switch(j){
6243 case 0: //Layer5 EndCap Left Side
6244 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6245 cardinterfacematrix[i]);
6246 if(i!=0){
6247 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6248 mothersupplycardmatrix[i]);
6249 index[j]++;
6250
6251 }
6252 break;
6253 case 1: //Layer5 EndCap Rigth Side
6254 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6255 cardinterfacematrix[i]);
6256 if(i>0&&i<6){
6257 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6258 mothersupplycardmatrix[i]);
6259 index[j]++;
6260 }
6261 break;
6262 case 2: //Layer6 EndCap Left Side
6263 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6264 cardinterfacematrix[i]);
6265 if(i!=6){
6266 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6267 mothersupplycardmatrix[i]);
6268 index[j]++;
6269 }
6270 break;
6271 case 3: //Layer6 EndCap Right Side
6272 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6273 cardinterfacematrix[i]);
6274 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6275 mothersupplycardmatrix[i]);
6276 index[j]++;
6277 break;
6278 }
6279 }
6280 }
6281 // Positioning Interface
6282 TGeoTranslation* motherinterfacecardtrans =
6283 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6284 +0.5*fgkEndCapCardElectBoardBackThickness
6285 -fgkEndCapCardElectBoardLayerThickness
6286 +fgkEndCapStripConnectionThickness,0.,0.);
6287 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6288 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6289 // Positioning Interface Card B
6290 TGeoTranslation* interfacecardBmothertrans =
6291 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6292 + 2.*fgkEndCapStripConnectionThickness
6293 + fgkEndCapCardElectBoardBackThickness,0.,
6294 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6295 - fgkEndCapCardElectBoardBackLength[0]));
6296 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6297 interfacecardBmothertrans);
6298 // Positioning Stiffener
6299 TGeoTranslation* endcapstiffenertrans =
6300 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6301 + 2.0*fgkEndCapStripConnectionThickness
6302 + fgkEndCapInterfaceCardBThickness
6303 + fgkEndCapCardJMDConnectorLength[0]
6304 + stiffenertransx
6305 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6306 endcapstiffenershape->GetDZ()
6307 - 0.5*(fgkEndCapStiffenerLength
6308 - fgkEndCapCardElectBoardBackLength[0]));
6309 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6310 /////////////////////////////////////////////////////////////
6311 // Deallocating memory
6312 /////////////////////////////////////////////////////////////
6313 delete interfacecardBrot;
6314 delete interfacecardBtrans;
6315 delete electboardcardBtrans;
6316 delete electboardcardBrot;
6317 delete jmdconnectorcardBrot;
6318 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6319 delete jmdconnectorot;
6320 delete jmdconnectortrans[1];
6321 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6322 delete cableconnectorcombitrans;
6323 delete electboardbacktrans;
6324 delete electboardbackrot;
6325 delete electlayerrot;
6326 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6327 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6328 delete mothersupplycardtrans;
6329 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6330 /////////////////////////////////////////////////////////////
6331 return cardinterfacecontainer;
6332 }
6333 ////////////////////////////////////////////////////////////////////////////////
6334 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6335 /////////////////////////////////////////////////////////////
6336 // Method returning EndCap Mother Volume
6337 /////////////////////////////////////////////////////////////
6338 const Int_t kendcapcoverplatesmallholenumber = 9;
6339 Double_t endcapmotherorigin[3];
6340 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6341 + 0.5 *(fgkEndCapCoverPlateLength[3]
6342 + 2.0 * fgkEndCapCoverPlateLength[2]);
6343 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6344 - fgkEndCapCoverPlateWidth[2]
6345 - (kendcapcoverplatesmallholenumber-1)
6346 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6347 + 0.5*(fgkEndCapSideCoverLength[2]
6348 + fgkEndCapCoverPlateWidth[1]
6349 - fgkEndCapCoverPlateWidth[0])
6350 - (fgkEndCapCoverPlateWidth[1]
6351 - fgkEndCapCoverPlateWidth[0]);
6352 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6353 + 2.*fgkEndCapCoolingTubeRadiusMax
6354 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6355 + fgkEndCapSideCoverWidth[1]
6356 + fgkEndCapSideCoverThickness
6357 + fgkEndCapKaptonFoilThickness);
6358 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6359 + 2.0* fgkEndCapCoverPlateLength[2]
6360 + 2.0* fgkEndCapSideCoverThickness),
6361 0.5* (fgkEndCapSideCoverLength[2]
6362 + fgkEndCapCoverPlateWidth[1]
6363 - fgkEndCapCoverPlateWidth[0]),
6364 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6365 + fgkEndCapSideCoverWidth[1]
6366 + fgkEndCapSideCoverThickness
6367 + fgkEndCapKaptonFoilThickness),
6368 endcapmotherorigin);
6369 TGeoVolume** endcapassembly;
6370 endcapassembly = new TGeoVolume*[4];
6371 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6372 endcapmothershape,fSSDAir);
6373 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6374 endcapmothershape,fSSDAir);
6375 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6376 endcapmothershape,fSSDAir);
6377 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6378 endcapmothershape,fSSDAir);
6379 /////////////////////////////////
6380 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6381 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6382 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6383 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6384 /////////////////////////////////
6385 /////////////////////////////////////////////////////
6386 // Placing Endcap Cover Plate
6387 /////////////////////////////////////////////////////
6388 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6389 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6390 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6391 TGeoCombiTrans* endcapcoverplatecombitrans =
6392 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6393 endcapcoverplaterot);
6394 TGeoTranslation* endcapcoverplatetrans =
6395 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6396 TGeoHMatrix* endcapcoverplatematrix =
6397 new TGeoHMatrix((*endcapcoverplatetrans)
6398 * (*endcapcoverplatecombitrans));
6399 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6400 /////////////////////////////////////////////////////
6401 // Placing Endcap Side Cover
6402 /////////////////////////////////////////////////////
6403 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6404 TGeoRotation* endcapsidecoverot[2];
6405 TGeoCombiTrans* endcapsidecovercombitrans[3];
6406 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6407 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6408 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6409 - 0.5*(fgkEndCapCoverPlateWidth[0]
6410 - fgkEndCapCoverPlateWidth[2]
6411 - (kendcapcoverplatesmallholenumber-1)
6412 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6413 + 0.*fgkEndCapCoverPlateWidth[0]
6414 + fgkEndCapSideCoverLength[2],
6415 0.5*(fgkEndCapSideCoverThickness
6416 + fgkEndCapCoverPlateThickness)
6417 - 0.5*fgkEndCapCoverPlateThickness,
6418 endcapsidecoverot[0]);
6419 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6420 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6421 0.5*fgkEndCapCoverPlateThickness
6422 -fgkEndCapSideCoverWidth[1],
6423 endcapsidecoverot[1]);
6424 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6425 +fgkEndCapCoverPlateLength[3]
6426 +2.*fgkEndCapCoverPlateLength[2]
6427 +fgkEndCapSideCoverThickness,0.0,
6428 0.5*fgkEndCapCoverPlateThickness
6429 -fgkEndCapSideCoverWidth[1],
6430 endcapsidecoverot[1]);
6431 TGeoHMatrix* endcapsidecovermatrix[2];
6432 for(Int_t i=0; i<2; i++){
6433 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6434 * (*endcapsidecovercombitrans[0]));
6435 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6436 endcapsidecovermatrix[i]);
6437 }
6438 /////////////////////////////////////////////////////
6439 // Placing Endcap Cooling Tube
6440 /////////////////////////////////////////////////////
6441 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6442 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6443 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6444 TGeoCombiTrans* endcapccolingtubecombitrans
6445 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6446 + fgkEndCapCoolingTubeAxialRadius[1])
6447 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6448 - fgkEndCapCoolingTubeToCoverSide,
6449 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6450 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6451 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6452 endcapccolingtubecombitrans);
6453 /////////////////////////////////////////////////////
6454 // Placing Screws
6455 /////////////////////////////////////////////////////
6456 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6457 fgkEndCapCoverPlateScrewRadiusMin};
6458 Int_t screwcoverplatedgesnumber[2] = {20,20};
6459 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6460 fgkEndCapCoverPlateThickness
6461 + fgkEndCapCoolingTubeRadiusMax};
851c0ce3 6462 TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
9b0c60ab 6463 screwcoverplatedgesnumber,
6464 screwcoverplatesection);
6465 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6466 screwcoverplateshape,
6467 fSSDCoolingTubePhynox);
6468 screwcoverplate->SetLineColor(12);
6469 Double_t transx[4] = {0,
6470 fgkEndCapCoverPlateSmallHoleSeparation[0],
6471 fgkEndCapCoverPlateSmallHoleSeparation[0]
6472 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6473 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6474 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6475 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6476// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6477 TGeoTranslation*** endcapcoverplatescrewtrans;
6478 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6479 Int_t index = 0;
6480 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6481 endcapcoverplatescrewtrans[i] =
6482 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6483 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6484 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6485 if(index==1||index==9||index==28||index==36){
6486 endcapcoverplatescrewtrans[i][j] =
6487 new TGeoTranslation(transx[i],
6488 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6489 fgkEndCapSideCoverThickness);
6490 }
6491 else{
6492 endcapcoverplatescrewtrans[i][j] =
6493 new TGeoTranslation(transx[i],
6494 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6495 0.);
6496 }
6497 if(index!=19)
6498 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6499 endcapcoverplatescrewtrans[i][j]);
6500 }
6501 }
6502 /////////////////////////////////////////////////////
6503 // Placing Cover Plate Clips
6504 /////////////////////////////////////////////////////
6505 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6506 0.5*fgkEndCapCoverPlateClipWidth,
6507 0.5*fgkEndCapSideCoverThickness);
6508 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6509 endcapcoverplateclipshape,
6510 fSSDCoolingTubePhynox);
6511 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6512 0.5*fgkEndCapCoverPlateDownClipWidth,
6513 0.5*fgkEndCapSideCoverThickness);
6514 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6515 endcapcoverplatedownclipshape,
6516 fSSDCoolingTubePhynox);
6517 TGeoTranslation* endcapcoverplatecliptrans[4];
6518 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6519 - fgkEndCapCoverPlateLength[0]
6520 - fgkEndCapSideCoverThickness,
6521 0.0,
6522 0.5*(fgkEndCapSideCoverThickness
6523 + fgkEndCapCoverPlateThickness));
6524 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6525 - fgkEndCapCoverPlateLength[0]
6526 - fgkEndCapSideCoverThickness,
6527 (kendcapcoverplatescrewnumber[1]-1)
6528 * fgkEndCapSideCoverWidth[5],
6529 0.5*(fgkEndCapSideCoverThickness
6530 + fgkEndCapCoverPlateThickness));
6531 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6532 - fgkEndCapCoverPlateLength[0]
6533 + fgkEndCapCoverPlateLength[1]
6534 + 2.*fgkEndCapCoverPlateLength[0]
6535 - fgkEndCapCoverPlateClipLength
6536 + fgkEndCapSideCoverThickness,
6537 0.0,
6538 0.5*(fgkEndCapSideCoverThickness
6539 + fgkEndCapCoverPlateThickness));
6540 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6541 - fgkEndCapCoverPlateLength[0]
6542 + fgkEndCapCoverPlateLength[1]
6543 + 2.*fgkEndCapCoverPlateLength[0]
6544 - fgkEndCapCoverPlateClipLength
6545 + fgkEndCapSideCoverThickness,
6546 (kendcapcoverplatescrewnumber[1]-1)
6547 * fgkEndCapSideCoverWidth[5],
6548 0.5*(fgkEndCapSideCoverThickness
6549 + fgkEndCapCoverPlateThickness));
6550 endcapcoverplateclip->SetLineColor(fColorPhynox);
6551 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6552 for(Int_t i=0; i<4; i++)
6553 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6554 endcapcoverplatecliptrans[i]);
6555 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6556 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6557 - fgkEndCapCoverPlateLength[0]
6558 - fgkEndCapSideCoverThickness,
6559 0.5*(fgkEndCapCoverPlateDownClipWidth
6560 - fgkEndCapCoverPlateClipWidth),
6561 0.5*(fgkEndCapSideCoverThickness
6562 + fgkEndCapCoverPlateThickness)
6563 - fgkEndCapSideCoverWidth[1]
6564 - fgkEndCapSideCoverThickness);
6565 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6566 - fgkEndCapCoverPlateLength[0]
6567 - fgkEndCapSideCoverThickness,
6568 0.5*(fgkEndCapCoverPlateDownClipWidth
6569 - fgkEndCapCoverPlateClipWidth)
6570 + fgkEndCapSideCoverLength[2]
6571 - fgkEndCapCoverPlateDownClipWidth,
6572 0.5*(fgkEndCapSideCoverThickness
6573 + fgkEndCapCoverPlateThickness)
6574 - fgkEndCapSideCoverWidth[1]
6575 - fgkEndCapSideCoverThickness);
6576 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6577 - fgkEndCapCoverPlateLength[0]
6578 + fgkEndCapSideCoverThickness
6579 + fgkEndCapCoverPlateLength[1]
6580 + 2.0*fgkEndCapCoverPlateLength[0]
6581 - fgkEndCapCoverPlateDownClipLength,
6582 0.5*(fgkEndCapCoverPlateDownClipWidth
6583 - fgkEndCapCoverPlateClipWidth),
6584 0.5*(fgkEndCapSideCoverThickness
6585 + fgkEndCapCoverPlateThickness)
6586 - fgkEndCapSideCoverWidth[1]
6587 - fgkEndCapSideCoverThickness);
6588 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6589 - fgkEndCapCoverPlateLength[0]
6590 + fgkEndCapSideCoverThickness
6591 + fgkEndCapCoverPlateLength[1]
6592 + 2.0*fgkEndCapCoverPlateLength[0]
6593 - fgkEndCapCoverPlateDownClipLength,
6594 0.5*(fgkEndCapCoverPlateDownClipWidth
6595 - fgkEndCapCoverPlateClipWidth)
6596 + fgkEndCapSideCoverLength[2]
6597 - fgkEndCapCoverPlateDownClipWidth,
6598 0.5*(fgkEndCapSideCoverThickness
6599 + fgkEndCapCoverPlateThickness)
6600 - fgkEndCapSideCoverWidth[1]
6601 - fgkEndCapSideCoverThickness);
6602 for(Int_t i=0; i<4; i++)
6603 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6604 endcapcoverplatedowncliptrans[i]);
6605 /////////////////////////////////////////////////////
6606 // Placing Kapton Foil
6607 /////////////////////////////////////////////////////
6608 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6609 0.5*fgkEndCapKaptonFoilWidth,
6610 0.5*fgkEndCapKaptonFoilThickness);
6611 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6612 endcapkaptonfoilshape,
6613 fSSDKaptonFlexMedium);
6614 endcapkaptonfoil->SetLineColor(8);
6615 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6616 0.5*fgkEndCapKaptonFoilWidth
6617 - 0.5*fgkEndCapCoverPlateClipWidth,
6618 0.5*fgkEndCapCoverPlateThickness
6619 - 0.5*fgkEndCapKaptonFoilThickness
6620 - fgkEndCapSideCoverWidth[1]
6621 - fgkEndCapSideCoverThickness);
6622 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6623 /////////////////////////////////////////////////////////////
6624 // Placing Electronic Tubes
6625 /////////////////////////////////////////////////////////////
6626 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6627 - fgkEndCapInterfaceCardBThickness
6628 - 9.*fgkEndCapStripConnectionThickness
6629 - 8.*fgkEndCapCardElectBoardBackThickness,
6630 fgkEndCapKaptonFoilWidth
6631 - fgkEndCapInterfaceCardBThickness
6632 - 9.*fgkEndCapStripConnectionThickness
6633 - 8.*fgkEndCapCardElectBoardBackThickness
6634 - fgkEndCapInterfaceElectBoardCardBThickness};
6635 TGeoVolume* endcapeffectivecables[2];
6636 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6637 fgkEndCapEffectiveCableRadiusMax,
6638 endcapeffectivecableswidth[0],
6639 10,"EndCapEffectiveCables1");
6640 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6641 fgkEndCapEffectiveCableRadiusMax,
6642 endcapeffectivecableswidth[1],
6643 25,"EndCapEffectiveCables2");
6644 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6645 TGeoTranslation* endcapeffectivecablestrans[2];
6646 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6647 - 0.5*endcapeffectivecableswidth[0]
6648 - 0.5*(fgkEndCapCoverPlateWidth[0]
6649 - fgkEndCapCoverPlateWidth[2]
6650 - (kendcapcoverplatesmallholenumber-1)
6651 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6652 + fgkEndCapSideCoverLength[2],
6653 - 0.5*fgkEndCapCoverPlateThickness
6654 - (fgkEndCapCardElectBoardBackWidth[0]
6655 - fgkEndCapInterfaceCardBWidth[0]
6656 - fgkEndCapInterfaceCardBWidth[1]));
6657 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6658 - 0.5*endcapeffectivecableswidth[1]
6659 - 0.5*(fgkEndCapCoverPlateWidth[0]
6660 - fgkEndCapCoverPlateWidth[2]
6661 - (kendcapcoverplatesmallholenumber-1)
6662 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6663 + fgkEndCapSideCoverLength[2],
6664 - 0.5*fgkEndCapCoverPlateThickness
6665 - (fgkEndCapCardElectBoardBackWidth[0]
6666 - fgkEndCapInterfaceCardBWidth[0])
6667 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6668 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6669 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6670 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6671 *endcapeffectivecablesrot);
6672 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6673 *endcapeffectivecablesrot);
47f8de53 6674// for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6675// endcapeffectivecablescombitrans[0]);
9b0c60ab 6676 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6677 endcapeffectivecablescombitrans[1]);
6678 /////////////////////////////////////////////////////////////
6679 // Placing End Cap Cards
6680 /////////////////////////////////////////////////////////////
6681 TGeoVolume** endcapcards = GetEndCapCards();
6682 TGeoRotation* endcapcardsrot[2];
6683 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6684 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6685 TGeoTranslation* endcapcardstrans[2];
6686 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6687 - fgkEndCapCardElectBoardBackLength[0]));
6688 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6689 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6690 TGeoHMatrix* endcapcardsmatrix[2];
6691 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6692 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6693 - fgkEndCapCardJMDConnectorLength[0]
6694 - fgkEndCapInterfaceCardBThickness
6695 - 9.*fgkEndCapStripConnectionThickness
6696 - 8.*fgkEndCapCardElectBoardBackThickness;
6697 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6698 - fgkEndCapCoverPlateLength[0]
6699 + 0.5 * (fgkEndCapCoverPlateLength[3]
6700 + 2.0 * fgkEndCapCoverPlateLength[2]),
6701 - stiffenertransx-fgkEndCapStiffenerWidth
6702 - fgkEndCapCardJMDConnectorLength[0]
6703 - fgkEndCapInterfaceCardBThickness
6704 - 2.0 * fgkEndCapStripConnectionThickness
6705 - 1.5 * fgkEndCapInterfaceCardBThickness
6706 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6707 - fgkEndCapCoverPlateWidth[2]
6708 - (kendcapcoverplatesmallholenumber-1)
6709 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6710 + fgkEndCapKaptonFoilWidth,
6711 0.5*fgkEndCapCoverPlateThickness
6712 - fgkEndCapSideCoverWidth[1]);
6713 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6714 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6715 /////////////////////////////////////////////////////////////
6716 // Deallocating memory
6717 /////////////////////////////////////////////////////////////
6718 delete endcapcoverplaterot;
6719 delete endcapcoverplatecombitrans;
6720 delete endcapcoverplatetrans;
6721 for(Int_t i=0; i<3; i++){
6722 delete endcapsidecovercombitrans[i];
6723 if(i<2) delete endcapsidecoverot[i];
6724 }
6725 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6726 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6727 delete endcapcardsmatrix[0];
6728 return endcapassembly;
6729 }
6730 ////////////////////////////////////////////////////////////////////////////////
6731 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6732 Double_t radiusmax,
6733 Double_t width,
6734 Int_t ncables,
a6e0ebfe 6735 const char* volname){
9b0c60ab 6736 /////////////////////////////////////////////////////////////
6737 // Generating EndCap High Voltage Tubes
6738 /////////////////////////////////////////////////////////////
6739 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
60e55aee 6740 Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6741
9b0c60ab 6742 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6743 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6744 effectiveouteradius,0.5*width);
6745 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6746 effectiveinnertubeshape,
6747 fSSDStiffenerConnectorMedium);
6748 effectiveinnertube->SetLineColor(41);
6749 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6750 effectiveoutertubeshape,
6751 fSSDKaptonChipCableMedium);
6752 effectiveoutertube->SetLineColor(39);
6753 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6754 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6755 effectivemothertube->AddNode(effectiveinnertube,1);
6756 effectivemothertube->AddNode(effectiveoutertube,1);
6757 return effectivemothertube;
6758 }
6759 ////////////////////////////////////////////////////////////////////////////////
6760 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6761 /////////////////////////////////////////////////////////////
6762 // Generating EndCap Support Layer 5 and Layer 6
6763 /////////////////////////////////////////////////////////////
6764 const Int_t knedges = 5;
6765 ///////////////////////////////////////////////
6766 // Setting the vertices for TGeoXtru Up Volume
6767 ///////////////////////////////////////////////
6768 const Int_t klayernumber = 2;
6769 Double_t xupvertex[klayernumber][knedges+3];
6770 Double_t yupvertex[klayernumber][knedges+3];
6771 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6772 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6773 Double_t middlepsi[klayernumber] = {0.0,0.0};
6774 for(Int_t i=0; i<klayernumber; i++){
6775 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6776 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6777 xupvertex[i][2] = -xupvertex[i][1];
6778 xupvertex[i][3] = -xupvertex[i][0];
6779
6780 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6781 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6782 yupvertex[i][2] = yupvertex[i][1];
6783 yupvertex[i][3] = yupvertex[i][0];
6784
6785 middledgeangle[i] = upedgeangle[i]/knedges;
6786 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6787 for(Int_t j=1; j<knedges; j++){
6788 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6789 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6790 }
6791 }
6792 ////////////////////////////////////
6793 // Generating Up TGeoXtru
6794 ////////////////////////////////////
6795 TGeoXtru* upendcapsupportshape[klayernumber];
6796 TGeoVolume* upendcapsupport[klayernumber];
a3f8715e 6797 char upendcapsupportname[100];
9b0c60ab 6798 for(Int_t i=0; i<klayernumber; i++){
6799 upendcapsupportshape[i] = new TGeoXtru(2);
045be90c 6800 snprintf(upendcapsupportname,100,"UpEndCapSupportPieceLayer%i",i+5);
9b0c60ab 6801 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6802 upendcapsupportshape[i]->DefineSection(0,0.);
6803 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6804 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 6805 fSSDSupportRingAl);
9b0c60ab 6806 upendcapsupport[i]->SetLineColor(5);
6807 }
6808 ///////////////////////////////////////////////
6809 // Setting the vertices for TGeoXtru Down Volume
6810 ///////////////////////////////////////////////
6811 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6812 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6813 for(Int_t i=0; i<klayernumber; i++){
6814 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6815 xdownvertex[i][1] = xupvertex[i][0];
6816 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6817 ydownvertex[i][1] = yupvertex[i][0];
6818 for(Int_t j=0; j<knedges; j++){
6819 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6820 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6821 }
6822 for(Int_t j=0; j<knedges; j++){
6823 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6824 * CosD(middlepsi[i]+j*middledgeangle[i]);
6825 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6826 * SinD(middlepsi[i]+j*middledgeangle[i]);
6827 }
6828 }
6829 ////////////////////////////////////
6830 // Generating Down TGeoXtru
6831 ////////////////////////////////////
6832 TGeoXtru* downendcapsupportshape[klayernumber];
6833 TGeoVolume* downendcapsupport[klayernumber];
a3f8715e 6834 char downendcapsupportname[100];
9b0c60ab 6835 for(Int_t i=0; i<klayernumber; i++){
6836 downendcapsupportshape[i] = new TGeoXtru(2);
045be90c 6837 snprintf(downendcapsupportname,100,"DownEndCapSupportPieceLayer%i",i+5);
9b0c60ab 6838 downendcapsupportshape[i] = new TGeoXtru(2);
6839 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6840 if(i==0){
6841 downendcapsupportshape[i]->DefineSection(0,0.);
6842 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6843 }
6844 else{
6845 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6846 - fgkEndCapSupportLowWidth[i]);
6847 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6848 }
6849 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 6850 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 6851 downendcapsupport[i]->SetLineColor(5);
6852 }
6853 ///////////////////////////////////////////////
6854 // Setting TGeoPgon Volume
6855 ///////////////////////////////////////////////
6856 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6857 fgkSSDLay6LadderNumber};
6858 TGeoPgon* endcapsupportmothershape[klayernumber];
6859 TGeoVolume** endcapsupportmother;
6860 endcapsupportmother = new TGeoVolume*[klayernumber];
a3f8715e 6861 char endcapsupportmothername[100];
9b0c60ab 6862 for(Int_t i=0; i<klayernumber; i++){
6863 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
045be90c 6864 snprintf(endcapsupportmothername,100,"EndCapSupportMotherLayer%i",i+5);
9b0c60ab 6865 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6866 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6867 ydownvertex[i][0],yupvertex[i][1]);
6868 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 6869 fSSDAir);
9b0c60ab 6870 }
6871 ////////////////////////////////////
6872 TGeoRotation** endcapsupportrot[klayernumber];
6873 for(Int_t i=0; i<2; i++){
6874 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6875 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6876 endcapsupportrot[i][j] = new TGeoRotation();
6877 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6878 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6879 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6880 }
6881 }
6882 return endcapsupportmother;
6883 }
6884 ////////////////////////////////////////////////////////////////////////////////
6885 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6886 /////////////////////////////////////////////////////////////
6887 // Setting End Cap Support Layer 5 and 6.
6888 /////////////////////////////////////////////////////////////
6889 const Int_t kendcapcoverplatesmallholenumber = 9;
6890 const Int_t klayernumber = 2;
6891 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6892 fgkSSDLay6LadderNumber};
6893 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6894 360.0/kssdlayladdernumber[1]};
6895 TGeoVolume** endcapsupport = EndCapSupport();
6896 TGeoVolume** endcapassembly = GetEndCapAssembly();
6897 TGeoPgon* endcapsupportshape[klayernumber];
6898 Double_t* radiusmin[klayernumber];
6899 Double_t* radiusmax[klayernumber];
6900 for(Int_t i=0; i<klayernumber; i++){
6901 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6902 radiusmin[i] = endcapsupportshape[i]->GetRmin();
6903 radiusmax[i] = endcapsupportshape[i]->GetRmax();
6904 }
6905 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6906 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6907 endcapassemblyshape->GetDY(),
6908 endcapassemblyshape->GetDZ()};
6909 ///////////////////////////////////////////////
6910 // Setting TGeoPgon Volume for Mother Container
6911 ///////////////////////////////////////////////
6912 TGeoPgon* endcapsupportsystemshape[klayernumber];
a3f8715e 6913 char endcapsupportsystemothername[100];
9b0c60ab 6914 for(Int_t i=0; i<klayernumber; i++){
6915 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
045be90c 6916 snprintf(endcapsupportsystemothername,100,"EndCapSupportSystemLayer%i",i+5);
9b0c60ab 6917 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
6918 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
6919 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6920 +2.*endcapassemblycenter[2])
6921 /CosD(0.5*upedgeangle[i]));
6922 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
6923 -(fgkEndCapCoverPlateWidth[1]
6924 - fgkEndCapCoverPlateWidth[0]),
6925 *radiusmin[i],
6926 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6927 +2.*endcapassemblycenter[2])
6928 /CosD(0.5*upedgeangle[i]));
6929 }
e5bf64ae 6930 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 6931 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
6932 endcapsupportsystemshape[0],fSSDAir);
6933 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
6934 endcapsupportsystemshape[0],fSSDAir);
6935 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
6936 endcapsupportsystemshape[1],fSSDAir);
6937 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
6938 endcapsupportsystemshape[1],fSSDAir);
6939 ///////////////////////////////////////////////
6940 TGeoTranslation* endcapassemblytrans[klayernumber];
6941 for(Int_t i=0; i<klayernumber; i++)
6942 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
6943 - fgkEndCapSideCoverThickness
6944 + endcapassemblycenter[0],
6945 - 0.5*fgkEndCapCoverPlateThickness
6946 - 2.0*fgkEndCapCoolingTubeRadiusMax
6947 + 2.0*endcapassemblycenter[2]
6948 + 0.5*fgkEndCapSupportLength[i]
6949 / TanD(0.5*upedgeangle[i]),
6950 0.5*(fgkEndCapCoverPlateWidth[0]
6951 - fgkEndCapCoverPlateWidth[2]
6952 - (kendcapcoverplatesmallholenumber-1)
6953 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
6954 TGeoRotation** endcapassemblyrot[klayernumber];
6955 TGeoHMatrix** endcapassemblymatrix[klayernumber];
6956 for(Int_t i=0; i<klayernumber; i++){
6957 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
6958 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
6959 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
6960 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
6961 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
6962 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
6963 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
6964 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6965 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
6966 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
6967 }
6968 }
6969 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
6970 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
6971 for(Int_t i=0; i<2*klayernumber; i++){
6972 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
6973 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
6974 endcapassemblymatrix[1][j+2]);
6975 }
6976 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
6977 }
6978 /////////////////////////////////////////////////////////////
6979 // Deallocating memory
6980 /////////////////////////////////////////////////////////////
6981 for(Int_t i=0; i<klayernumber; i++){
6982 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
6983 delete endcapassemblyrot[i][j];
6984 }
7b208ef4 6985 delete [] endcapassemblyrot[i];
9b0c60ab 6986 delete endcapassemblymatrix[i][0];
6987 delete endcapassemblymatrix[i][1];
6988 }
6989 /////////////////////////////////////////////////////////////
6990 }
6991 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
6992 /////////////////////////////////////////////////////////////
6993 // Setting End Cap Support + End Cap Assembly of Layer 5.
6994 /////////////////////////////////////////////////////////////
6995 if (! moth) {
160835d5 6996 AliError("Can't insert end cap support of layer5, mother is null!\n");
9b0c60ab 6997 return;
6998 };
e5bf64ae 6999 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7000 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7001 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7002 fgkEndCapSupportCenterLay5ITSPosition
7003 + fgkEndCapSupportCenterLay5Position
7004 - fgkEndCapSideCoverLength[2]);
7005 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7006 fgkEndCapSideCoverLength[2]
7007 - fgkEndCapSupportCenterLay5Position
7008 - fgkEndCapSupportCenterLay5ITSPosition);
7009 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7010 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7011 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7012 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7013 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7014 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7015 /////////////////////////////////////////////////////////////
7016 // Deallocating memory
7017 /////////////////////////////////////////////////////////////
7018 delete endcapsupportsystemrot;
7019 delete endcapsupportsystemITSCentertrans[1];
7020 }
7021 /////////////////////////////////////////////////////////////
7022 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7023 /////////////////////////////////////////////////////////////
7024 // Setting End Cap Support + End Cap Assembly of Layer 6.
7025 /////////////////////////////////////////////////////////////
7026 if (! moth) {
160835d5 7027 AliError("Can't insert end cap support of layer6, mother is null!\n");
9b0c60ab 7028 return;
7029 };
e5bf64ae 7030 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7031 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7032 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7033 fgkEndCapSupportCenterLay6ITSPosition
7034 + fgkEndCapSupportCenterLay6Position
7035 - fgkEndCapSideCoverLength[2]);
7036 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7037 fgkEndCapSideCoverLength[2]
7038 - fgkEndCapSupportCenterLay6Position
7039 - fgkEndCapSupportCenterLay6ITSPosition);
7040 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7041 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7042 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7043 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7044 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7045 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7046 /////////////////////////////////////////////////////////////
7047 // Deallocating memory
7048 /////////////////////////////////////////////////////////////
7049 delete endcapsupportsystemrot;
7050 delete endcapsupportsystemITSCentertrans[1];
7051 }
7052 ////////////////////////////////////////////////////////////////////////////////
7053 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7054 /////////////////////////////////////////////////////////////
7055 // Setting Ladder Support of Layer 5.
7056 /////////////////////////////////////////////////////////////
7057 if (! moth) {
160835d5 7058 AliError("Can't insert ladder lupport of layer5, mother is null!\n");
9b0c60ab 7059 return;
7060 };
7061 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7062 fMotherVol = moth;
7063 TGeoTranslation* centerITSRingSupportLay5trans[2];
7064 for(Int_t i=0; i<2; i++){
7065 centerITSRingSupportLay5trans[i] =
7066 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7067 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7068 }
7069 }
7070 ////////////////////////////////////////////////////////////////////////////////
7071 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7072 /////////////////////////////////////////////////////////////
7073 // Setting Ladder Support of Layer 6.
7074 /////////////////////////////////////////////////////////////
7075 if (! moth) {
160835d5 7076 AliError("Can't insert ladder lupport of layer6, mother is null!\n");
9b0c60ab 7077 return;
7078 };
7079 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7080 fMotherVol = moth;
7081 TGeoTranslation* centerITSRingSupportLay6trans[2];
7082 for(Int_t i=0; i<2; i++){
7083 centerITSRingSupportLay6trans[i] =
7084 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7085 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7086 }
7087 }
7088 ////////////////////////////////////////////////////////////////////////////////
47f8de53 7089 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7090 /////////////////////////////////////////////////////////////
7091 // Setting Ladder Support of Layer 6.
7092 /////////////////////////////////////////////////////////////
7093 if (! moth) {
160835d5 7094 AliError("Can't insert SSD Cone, mother is null!\n");
47f8de53 7095 return;
7096 };
7097 if(!fSSDCone) SetSSDCone();
7098 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7099 + fgkSSDCentralAL3SupportLength);
7100 moth->AddNode(fSSDCone,1,ssdconetrans);
7101}
7102 ////////////////////////////////////////////////////////////////////////////////
7103 void AliITSv11GeometrySSD::SetSSDCone(){
7104 /////////////////////////////////////////////////////////////
7105 // Method generating SSDCone
7106 /////////////////////////////////////////////////////////////
7107 if(!fCreateMaterials) CreateMaterials();
7108 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7109 Double_t ssdpconesectionradiusmax[16];
7110 Double_t ssdpconesectionradiusmin[16];
7111 Double_t ssdpconezsection[16];
7112 TGeoPcon* ssdpconelittleholeshape[8];
7113 TGeoVolume* ssdpconelittlehole[8];
7114 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7115 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7116 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7117 / SinD(fgkSSDPConeAngle)
7118 + ssdpconesectionradiusmin[0];
7119 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7120 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7121 / SinD(fgkSSDPConeAngle);
7122 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7123 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7124 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7125 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7126 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7127 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7128 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7129 ssdpconelittlehole[0]->SetLineColor(4);
7130 /////////////////////////////////////////////////////////////
7131 ssdpconezsection[2] = ssdpconezsection[1];
7132 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7133 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7134 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7135 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7136 / SinD(fgkSSDPConeAngle);
7137 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7138 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7139 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7140 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7141 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7142 * TMath::RadToDeg();
7143 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7144 60.-ssdpconelittleholeangle,2);
7145 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7146 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7147 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7148 ssdpconelittlehole[1]->SetLineColor(4);
7149 TGeoRotation* ssdconelittleholerot[6];
7150 for(Int_t i=0; i<6; i++){
7151 ssdconelittleholerot[i] = new TGeoRotation();
7152 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7153 }
7154 /////////////////////////////////////////////////////////////
7155 ssdpconezsection[4] = ssdpconezsection[3];
7156 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7157 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7158 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7159 * CosD(fgkSSDPConeAngle)
7160 / SinD(fgkSSDPConeAngle);
7161 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7162 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7163 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7164 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7165 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7166 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7167 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7168 ssdpconelittlehole[2]->SetLineColor(4);
7169 ///////////////////////////////////////////////////
7170 ssdpconezsection[6] = ssdpconezsection[5];
7171 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7172 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7173 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7174 -ssdpconezsection[0]
7175 * CosD(fgkSSDPConeAngle)
7176 / SinD(fgkSSDPConeAngle);
7177 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7178 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7179 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7180 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7181 * TMath::RadToDeg();
7182 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7183 45.-ssdpconemiddleholeangle,2);
7184 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7185 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7186 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7187 ssdpconelittlehole[3]->SetLineColor(4);
7188 TGeoRotation* ssdconemiddleholerot[8];
7189 for(Int_t i=0; i<8; i++){
7190 ssdconemiddleholerot[i] = new TGeoRotation();
7191 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7192 }
7193 /////////////////////////////////////////////////////////////
7194 ssdpconezsection[8] = ssdpconezsection[7];
7195 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7196 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7197 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7198 * CosD(fgkSSDPConeAngle)
7199 / SinD(fgkSSDPConeAngle);
7200 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7201 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7202 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7203 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7204 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7205 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7206 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7207 ssdpconelittlehole[4]->SetLineColor(4);
7208 /////////////////////////////////////////////////////////////
7209 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7210 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7211 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7212 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7213 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7214 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7215 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7216 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7217 * TMath::RadToDeg();
7218 ssdpconezsection[10] = ssdpconezsection[9];
7219 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7220 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7221 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7222 * CosD(fgkSSDPConeAngle)
7223 / SinD(fgkSSDPConeAngle);
7224 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7225 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7226 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7227 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7228 ssdpconetrapezoidsectionangle,2);
7229 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7230 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7231 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7232 ssdpconelittlehole[5]->SetLineColor(4);
7233 TGeoRotation* ssdconeupradiusrot[8];
7234 for(Int_t i=0; i<8; i++){
7235 ssdconeupradiusrot[i] = new TGeoRotation();
7236 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7237 }
7238 /////////////////////////////////////////////////////////////
7239 ssdpconezsection[12] = ssdpconezsection[11];
7240 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7241 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7242 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7243 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7244 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7245 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7246 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7247 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7248 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7249 ssdpconelittlehole[6]->SetLineColor(4);
7250 /////////////////////////////////////////////////////////////
7251 ssdpconezsection[14] = 0.0;
7252 ssdpconezsection[15] = ssdpconezsection[0];
7253 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7254 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7255 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7256 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7257 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7258 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7259 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7260 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7261 ssdpconelittlehole[7]->SetLineColor(4);
7262 /////////////////////////////////////////////////////////////
7263 TGeoTube* ssdtubeconeshape[2];
7264 TGeoVolume* ssdtubecone[2];
7265 TGeoTranslation* ssdtubeconetrans[2];
7266 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7267 fgkSSDPConeExternalRadius,
7268 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7269 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7270 0.5*ssdpconezsection[0]);
7271 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7272 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7273 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7274 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7275 + ssdpconezsection[13]);
7276 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7277 ssdtubecone[0]->SetLineColor(4);
7278 ssdtubecone[1]->SetLineColor(4);
7279 /////////////////////////////////////////////////////////////
7280 // Mother Volume Container
7281 /////////////////////////////////////////////////////////////
7282 Double_t ssdconemotherradiusmin[8];
7283 Double_t ssdconemotherradiusmax[8];
7284 Double_t ssdconemothersection[8];
7285 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7286 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7287 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7288 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7289 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7290 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7291 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7292 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7293 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7294 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7295 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7296 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7297 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7298 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7299 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7300 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7301 ssdconemothersection[0] = 0.0;
7302 ssdconemothersection[1] = ssdpconezsection[0];
7303 ssdconemothersection[2] = ssdpconezsection[0];
7304 ssdconemothersection[3] = ssdpconezsection[11];
7305 ssdconemothersection[4] = ssdpconezsection[11];
7306 ssdconemothersection[5] = ssdpconezsection[13];
7307 ssdconemothersection[6] = ssdpconezsection[13];
7308 ssdconemothersection[7] = fgkSSDPConeLength;
7309 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7310 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7311 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7312 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7313 /////////////////////////////////////////////////////////////
7314 //Placing the Volumes into Mother
7315 /////////////////////////////////////////////////////////////
7316 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7317 for(Int_t i=0; i<6; i++){
7318 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7319 }
7320 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7321 for(Int_t i=0; i<8; i++){
7322 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7323 }
7324 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7325 for(Int_t i=0; i<8; i++){
7326 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7327 }
7328 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7329 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7330 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7331 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7332 /////////////////////////////////////////////////////////////
7333 // ITS General Support
7334 /////////////////////////////////////////////////////////////
7335 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7336 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7337 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7338 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7339 - fgkSSDCentralAL3SupportLength);
7340 ssdcentralsupport->SetLineColor(4);
7341 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7342 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7343 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7344 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7345 TGeoTranslation* ssdcentralal3supportrans[3];
7346 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7347 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7348 - 1.25*fgkSSDCentralAL3SupportLength);
7349 ssdcentralal3support->SetLineColor(4);
7350 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7351 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7352 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7353 Double_t ssdpconcentralradiusmin[2];
7354 Double_t ssdpconcentralradiusmax[2];
7355 Double_t ssdpconcentralsection[2];
7356 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7357 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7358 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7359 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7360 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7361 ssdpconcentralsection[1] = 0.;
7362 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7363 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7364 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7365 ssdpconcentralal3->SetLineColor(4);
7366 fSSDCone->AddNode(ssdpconcentralal3,1);
7367 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7368 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7369 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7370 -2.*fgkSSDCentralAL3SupportLength);
7371 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7372 *ssdcentralal3supportrot);
7373 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7374 TGeoRotation* ssdconemotherot = new TGeoRotation();
7375 ssdconemotherot->SetAngles(90.,180.,-90.);
7376 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7377 -2.*fgkSSDCentralAL3SupportLength);
7378 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7379 fSSDCone->AddNode(ssdconemother,1);
7380 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7381 /////////////////////////////////////////////////////////////
7382 // Deallocating memory
7383 /////////////////////////////////////////////////////////////
7384 delete ssdcentralal3supportrot;
7385 delete ssdcentralal3supportrans[2];
7386 delete ssdconemotherot;
7387 delete ssdconemothertrans;
7388 /////////////////////////////////////////////////////////////
7389 }
fcfbdd23 7390 ////////////////////////////////////////////////////////////////////////////////
7391 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7392 /////////////////////////////////////////////////////////////
7393 // Setting SSD Cables
7394 /////////////////////////////////////////////////////////////
7395 if (! moth) {
160835d5 7396 AliError("Can't insert SSD Cables, mother is null!\n");
fcfbdd23 7397 return;
7398 };
7399 TGeoVolume* ssdcables = SetSSDCables();
7400 moth->AddNode(ssdcables,1);
7401}
47f8de53 7402 ////////////////////////////////////////////////////////////////////////////////
7403 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7404 /////////////////////////////////////////////////////////////
7405 // Method generating SSDCables
7406 /////////////////////////////////////////////////////////////
7407 // SSD Layer 5 Cables
7408 //////////////////////////////////////////////////////////////////////////////////////////////////
7409 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7410 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
fcfbdd23 7411 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
47f8de53 7412 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7413 //////////////////////////////////////////////////////////////////////////////////////////////////
7414 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+fgkSSDCablesLay5TubeRadiusMin;
7415 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7416 - fgkSSDLowerPConeRadius)
7417 * TanD(fgkSSDPConeAngle);
7418 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7419 + fgkEndCapSupportCenterLay5Position
7420 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7421 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7422 - ssdcableslay5startconedistance;
7423 ssdcablelay5rightsidelength *= ssdcablesfactor;
7424 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+fgkSSDCablesLay5RightSideHeight;
7425 TGeoTube* ssdcablelay5rightubeshape = new TGeoTube(ssdcableslay5rigthsideradiusmin,
7426 ssdcableslay5rightsideradiusmax,
7427 0.5*ssdcablelay5rightsidelength);
7428 TGeoVolume* ssdcablelay5righttube = new TGeoVolume("SSDCableLay5RightSideTube",
7429 ssdcablelay5rightubeshape,
7430 fSSDCopper);
7431 ssdcablelay5righttube->SetLineColor(9);
7432 TGeoTranslation* ssdcablelay5rightrans =
7433 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7434 + fgkEndCapSupportCenterLay5Position
7435 + 0.5*ssdcablelay5rightsidelength);
7436 ////////////////////////////////////
7437 // Double_t cablescapacity[20];
7438 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7439 ////////////////////////////////////
7440 ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7441 ////////////////////////////////////
7442 // TGeoPCone Volumes
7443 ///////////////////////////////////
7444 TGeoPcon* ssdcableslay5pconshape[3];
7445 TGeoVolume* ssdcableslay5pcon[3];
7446 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7447 Double_t ssdcableslay5pconzsection[6];
7448 Double_t ssdcableslay5pconrmin[6];
7449 Double_t ssdcableslay5pconrmax[6];
7450 ssdcableslay5pconrmin[0] = ssdcablelay5rightubeshape->GetRmin();
7451 ssdcableslay5pconrmax[0] = ssdcablelay5rightubeshape->GetRmax();
7452 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7453 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+fgkSSDCablesLay5RightSideHeight;
7454 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7455 + fgkEndCapSupportCenterLay5Position
7456 + 2.*ssdcablelay5rightubeshape->GetDz();
7457 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7458 + fgkSSDCentralAL3SupportLength
7459 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7460 * TanD(fgkSSDPConeAngle);
7461 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7462 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7463 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7464 ssdcableslay5pconshape[0],fSSDCopper);
7465 ssdcableslay5pcon[0]->SetLineColor(9);
7466 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7467////////////////////////////////////
7468// cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7469////////////////////////////////////
7470 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7471 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7472 + fgkSSDCentralAL3SupportLength
7473 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7474 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7475 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7476 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7477 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7478 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7479 ssdcableangle,2);
7480 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7481 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7482 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7483 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7484 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7485 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3]+fgkSSDCablesLay5RightSideHeight;
7486 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7487 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7488 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7489 ssdcableslay5pcon[1]->SetLineColor(9);
7490 ////////////////////////////////////
7491 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7492 ssdcableangle,2);
7493 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7494 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7495 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7496 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7497 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7498 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7499 * TanD(fgkSSDPConeAngle)
7500 + 0.5*fgkSSDCentralSupportLength
7501 + fgkSSDCentralAL3SupportLength;
7502 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7503 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7504 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7505 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7506 ssdcableslay5pcon[2]->SetLineColor(9);
7507////////////////////////////////////
7508 TGeoRotation* ssdcableslay5pconrot[4];
7509 for(Int_t i=0; i<4; i++){
7510 ssdcableslay5pconrot[i] = new TGeoRotation();
7511 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7512 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7513 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
7514 }
7515 ////////////////////////////////////
7516 //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7517 //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7518 ////////////////////////////////////
7519 // Positioning Left SSD Cables Part
7520 ////////////////////////////////////
7521 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7522 - 0.5*ssdcablelay5rightsidelength
7523 - fgkEndCapSupportCenterLay5Position
7524 - fgkEndCapSupportCenterLay5ITSPosition);
7525 ssdcablesmother->AddNode(ssdcablelay5righttube,2,ssdcablesLay5RightTubeToLeftrans);
7526 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7527 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7528 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7529 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7530 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7531 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7532 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7533 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7534 }
7535 ////////////////////////////////////
7536 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7537 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7538 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7539 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7540 /////////////////////////////////////////////////////////////
7541 // Water Tubes Layer 5
7542 /////////////////////////
7543 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7544 ssdcableslay5rightsideradiusmax
7545 + fgkSSDCablesLay5RightSideWaterHeight,
7546 0.5*ssdcablelay5rightsidelength);
7547 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7548 ssdcablelay5rightubewatershape,
7549 fSSDCoolingTubeWater);
7550 ssdcablelay5rightwatertube->SetLineColor(7);
7551 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7552 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7553 ////////////////////////////////////
7554 // TGeoPCone Water Volumes Layer
7555 ///////////////////////////////////
7556 TGeoPcon* ssdcableslay5pconwatershape[3];
7557 TGeoVolume* ssdcableslay5pconwater[3];
7558 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7559 Double_t ssdcableslay5pconwaterzsection[6];
7560 Double_t ssdcableslay5pcwateronrmin[6];
7561 Double_t ssdcableslay5pconwaterrmax[6];
7562 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7563 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7564 + fgkSSDCablesLay5RightSideWaterHeight;
7565 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7566 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7567 + fgkSSDCablesLay5RightSideWaterHeight;
7568 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7569 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7570 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7571 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7572 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7573 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7574 ssdcableslay5pconwater[0]->SetLineColor(7);
7575 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7576 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7577////////////////////////////////////
7578 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7579 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7580 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7581 ssdcableangle,2);
7582 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7583 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7584 + fgkSSDCablesLay5RightSideWaterHeight;
7585 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7586 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7587 + fgkSSDCablesLay5RightSideWaterHeight;
7588 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7589 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7590 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7591 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7592 ssdcableslay5pconwater[1]->SetLineColor(7);
7593////////////////////////////////////
7594 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7595 ssdcableangle,2);
7596 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7597 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7598 + fgkSSDCablesLay5RightSideWaterHeight;
7599 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7600 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7601 + fgkSSDCablesLay5RightSideWaterHeight;
7602 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7603 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7604 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7605 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7606 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7607 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7608 ssdcableslay5pconwater[2]->SetLineColor(7);
7609////////////////////////////////////
7610 TGeoRotation* ssdcableslay5pconwaterot[4];
7611 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7612 for(Int_t i=0; i<4; i++){
7613 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7614 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7615 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7616 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7617 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7618 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7619 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7620 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7621 }
7622 /////////////////////////
7623 // SSD Layer 6 Cables
7624 /////////////////////////
7625 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+fgkSSDCablesLay6TubeRadiusMin;
7626 Double_t ssdcablelay6rightsidelength = 2.*ssdcablelay5rightsidelength;
7627 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+fgkSSDCablesLay6RightSideHeight;
7628 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7629 ssdcableslay6rightsideradiusmax,
7630 0.5*ssdcablelay6rightsidelength);
7631 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7632 ssdcablelay6rightubeshape,
7633 fSSDCopper);
7634 ssdcablelay6righttube->SetLineColor(9);
7635 TGeoTranslation* ssdcablelay6rightrans =
7636 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7637 + fgkEndCapSupportCenterLay6Position
7638 + 0.5*ssdcablelay6rightsidelength);
7639 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7640 - 0.5*ssdcablelay6rightsidelength
7641 - fgkEndCapSupportCenterLay6Position
7642 - fgkEndCapSupportCenterLay6ITSPosition);
7643 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7644 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7645 ////////////////////////////////////
7646 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7647 ////////////////////////////////////
7648 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7649 ssdcableangle,2);
7650 TGeoVolume* ssdcableslay6pcon;
7651 Double_t ssdcableslay6pconrmin[2];
7652 Double_t ssdcableslay6pconrmax[2];
7653 Double_t ssdcableslay6pconzsection[2];
7654 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7655 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7656 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7657 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7658 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7659 + fgkEndCapSupportCenterLay6Position
7660 + ssdcablelay6rightsidelength;
7661 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7662 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7663 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7664 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7665 ssdcableslay6pconshape,fSSDCopper);
7666 ssdcableslay6pcon->SetLineColor(9);
7667 for(Int_t i=0; i<4; i++){
7668 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7669 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7670 }
7671 ////////////////////////////////////
7672 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7673 /////////////////////////
7674 // Water Tubes Layer 6
7675 /////////////////////////
7676 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7677 ssdcableslay6rightsideradiusmax
7678 + fgkSSDCablesLay5RightSideWaterHeight,
7679 0.5*ssdcablelay6rightsidelength);
7680 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7681 ssdcablelay6righwatertubeshape,
7682 fSSDCoolingTubeWater);
7683 ssdcablelay6rightwatertube->SetLineColor(7);
7684 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7685 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7686 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7687 ssdcableangle,2);
7688 TGeoVolume* ssdcableslay6waterpcon;
7689 Double_t ssdcableslay6waterpconrmin[2];
7690 Double_t ssdcableslay6waterpconrmax[2];
7691 Double_t ssdcableslay6waterpconzsection[2];
7692 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7693 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7694 + fgkSSDCablesLay5RightSideWaterHeight;
7695 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7696 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7697 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7698 + fgkEndCapSupportCenterLay6Position
7699 + ssdcablelay6rightsidelength;
7700 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7701 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7702 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7703 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7704 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7705 ssdcableslay6waterpcon->SetLineColor(7);
7706 TGeoRotation* ssdcableslay6pconwaterot[4];
7707 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7708 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7709 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7710 for(Int_t i=0; i<4; i++){
7711 ssdcableslay6pconwaterot[i] = new TGeoRotation();
7712 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7713 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7714 * (*ssdcableslay6pconwaterot[i]));
7715 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7716 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7717 }
7718 ////////////////////////////////////////
7719 // From ITS Ring to Patch Panel3-RB26
7720 ////////////////////////////////////////
7721 Double_t ssdcablepatchpanel3BB26radiusmin[2];
7722 Double_t ssdcablepatchpanel3BB26radiusmax[2];
7723 Double_t ssdcablepatchpanel3RB26zsection[2];
5d9d4033 7724 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8+0.003;//Avoid small overlap with SPDshieldring;
47f8de53 7725 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
7726 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7727 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7728 ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
7729 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
7730 + 0.*fgkSSDCablesLay5RightSideHeight
cd2243fb 7731 + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7732 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
7733 + fgkSSDCentralAL3SupportLength
7734 + fgkSSDPConeZLength[0];
7735 ssdcablepatchpanel3RB26zsection[1] = fgkSSDPatchPanel2RB26ITSDistance;
7736 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
7737 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7738 - 0.5*ssdcableangle,ssdcableangle,2);
7739 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7740 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7741 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7742 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7743 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
85f741d8 7744 TGeoRotation* ssdcablepatchpanel3B26rot[4];
47f8de53 7745 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
67446e8a 7746 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
47f8de53 7747 ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
67446e8a 7748 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7749 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
47f8de53 7750 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0]
67446e8a 7751 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
47f8de53 7752 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
7753 ////////////////////////////////////
7754 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7755 ////////////////////////////////////////
7756 // ITS Ring Cables RB26 Part
7757 ////////////////////////////////////////
7758 Double_t ssdcableitsring3BB26pconzsection[2];
7759 Double_t ssdcableitsring3BB26pconrmin[2];
7760 Double_t ssdcableitsring3BB26pconrmax[2];
7761 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7762 + fgkSSDCentralAL3SupportLength
7763 + (4.0/5.0)*fgkSSDPConeZLength[0];
7764 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
cd2243fb 7765 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
47f8de53 7766 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
7767 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7768 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7769 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7770 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7771 TGeoPcon* ssdcableitsring3BB26pconshape[4];
7772 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7773 - 0.5*ssdcableangle,ssdcableangle
7774 + (fgkSSDCablesPatchPanel2RB26Angle[0]
7775 - fgkSSDCableAngle),2);
7776 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7777 - 0.5*ssdcableangle,ssdcableangle
7778 + 3.0*fgkSSDCableAngle
7779 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7780 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-fgkSSDCablesPatchPanel2RB26Angle[0]
7781 - 0.5*ssdcableangle,ssdcableangle
7782 - fgkSSDCableAngle
7783 + fgkSSDCablesPatchPanel2RB26Angle[0],2);
7784 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7785 - 0.5*ssdcableangle,ssdcableangle
7786 + 3.0*fgkSSDCableAngle
7787 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7788 for(Int_t i=0;i<4;i++)
7789 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7790 ssdcableitsring3BB26pconrmin[j],
7791 ssdcableitsring3BB26pconrmax[j]);
7792 TGeoVolume* ssdcableitsring3BB26pcon[4];
7793 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7794 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7795 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7796 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7797 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7798 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7799 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7800 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7801 for(Int_t i=0;i<4;i++){
7802 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
5ef8864c 7803 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
47f8de53 7804}
7805 ////////////////////////////////////
7806 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7807 // + ssdcableitsring3BB26pconshape[1]->Capacity()
7808 // + ssdcableitsring3BB26pconshape[2]->Capacity()
7809 // + ssdcableitsring3BB26pconshape[3]->Capacity();
7810 ////////////////////////////////////////
7811 // From ITS Ring to Patch Panel2-RB24
7812 ////////////////////////////////////////
7813 Double_t ssdcablepatchpanel3BB24radiusmin[2];
7814 Double_t ssdcablepatchpanel3BB24radiusmax[2];
7815 Double_t ssdcablepatchpanel3RB24zsection[2];
7816 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7817 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
7818 ssdcablepatchpanel3BB24radiusmin[1] = fgkSSDPatchPanel2RB24Radius;
7819 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
7820 + 0.*fgkSSDCablesLay5RightSideHeight
7821 + 0.*fgkSSDCablesLay6RightSideHeight
cd2243fb 7822 + 0.5*fgkSSDPatchPanelHeight;
47f8de53 7823 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7824 - fgkSSDCentralAL3SupportLength
7825 - fgkSSDPConeZLength[0];
7826 ssdcablepatchpanel3RB24zsection[1] = -fgkSSDPatchPanel2RB24ITSDistance;
7827 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
7828 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7829 - 0.5*ssdcableangle,ssdcableangle,2);
7830 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7831 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7832 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7833 ssdcablepatchpanel3RB24pconshape,
7834 fSSDCopper);
7835 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
85f741d8 7836 TGeoRotation* ssdcablepatchpanel3B24rot[4];
47f8de53 7837 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
67446e8a 7838 ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
47f8de53 7839 ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0]
7840 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
67446e8a 7841 ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
47f8de53 7842 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0]
7843 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7844 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
7845 ////////////////////////////////////
7846 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7847 ////////////////////////////////////////
7848 // ITS Ring Cables RB24 Part
7849 ////////////////////////////////////////
7850 Double_t ssdcableitsring3BB24pconzsection[2];
7851 Double_t ssdcableitsring3BB24pconrmin[2];
7852 Double_t ssdcableitsring3BB24pconrmax[2];
7853 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7854 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
cd2243fb 7855 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
47f8de53 7856 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
7857 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7858 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7859 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
7860 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
7861 TGeoPcon* ssdcableitsring3BB24pconshape[4];
7862 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7863 + (90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7864 - fgkSSDCableAngle),2);
7865 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+fgkSSDCableAngle-0.5*ssdcableangle,
7866 ssdcableangle-fgkSSDCableAngle
7867 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
7868 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7869 - fgkSSDCableAngle
7870 + 90.0-fgkSSDCablesPatchPanel2RB24Angle[1],2);
5ef8864c 7871 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+fgkSSDCableAngle-0.5*ssdcableangle,
47f8de53 7872 ssdcableangle-fgkSSDCableAngle
7873 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
7874 for(Int_t i=0;i<4;i++)
7875 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
7876 ssdcableitsring3BB24pconrmin[j],
7877 ssdcableitsring3BB24pconrmax[j]);
7878 TGeoVolume* ssdcableitsring3BB24pcon[4];
7879 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
7880 ssdcableitsring3BB24pconshape[0],fSSDCopper);
7881 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
7882 ssdcableitsring3BB24pconshape[1],fSSDCopper);
7883 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
7884 ssdcableitsring3BB24pconshape[2],fSSDCopper);
7885 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
7886 ssdcableitsring3BB24pconshape[3],fSSDCopper);
7887 for(Int_t i=0;i<4;i++){
7888 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
5ef8864c 7889 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
47f8de53 7890}
7891 ////////////////////////////////////
7892 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
7893 // + ssdcableitsring3BB24pconshape[1]->Capacity()
7894 // + ssdcableitsring3BB24pconshape[2]->Capacity()
7895 // + ssdcableitsring3BB24pconshape[3]->Capacity();
7896 ////////////////////////////////////
7897 // Volumes for Material Budget
7898 ////////////////////////////////////
7899 TGeoTube* ssdcablelay6materialbudgetubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax
7900 + fgkSSDCablesLay5RightSideWaterHeight,
7901 ssdcableslay6rightsideradiusmax
7902 + fgkSSDCablesLay5RightSideWaterHeight
7903 + fgkSSDCableMaterialBudgetHeight,0.5*ssdcablelay6rightsidelength);
7904 TGeoVolume* ssdcablelay6materialbudgetube = new TGeoVolume("SSDCableLay6MaterialBudgetTube",
7905 ssdcablelay6materialbudgetubeshape,
7906 fSSDCopper);
7907 ssdcablelay6materialbudgetube->SetLineColor(9);
7908 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,1,ssdcablelay6rightrans);
7909 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,2,ssdcablesLay6RightTubeToLeftrans);
7910
7911 TGeoPcon* ssdcablelay6materialbudgetpconshape =
7912 new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
7913 TGeoVolume* ssdcablelay6materialbudgetpcon;
7914 Double_t ssdcablelay6materialbudgetpconrmin[2];
7915 Double_t ssdcablelay6materialbudgetpconrmax[2];
7916 Double_t ssdcablelay6materialbudgetpconzsection[2];
7917 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
7918 + fgkSSDCablesLay5RightSideWaterHeight;
7919 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
7920 + fgkSSDCableMaterialBudgetHeight;
7921 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
7922 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
7923 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7924 + fgkEndCapSupportCenterLay6Position
7925 + ssdcablelay6rightsidelength;
7926 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7927 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
7928 ssdcablelay6materialbudgetpconzsection[i],
7929 ssdcablelay6materialbudgetpconrmin[i],
7930 ssdcablelay6materialbudgetpconrmax[i]);
7931 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
7932 ssdcablelay6materialbudgetpconshape,fSSDCopper);
7933 ssdcablelay6materialbudgetpcon->SetLineColor(9);
7934 for(Int_t i=0; i<4; i++){
7935 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
7936 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7937 }
7938////////////////////////////////////
7939 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
7940 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
7941 Double_t ssdcablesvolume = 0.0;
7942 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
7943 std::cout << ssdcablesvolume << std::endl;*/
7944 return ssdcablesmother;
7945 }
7946 ////////////////////////////////////////////////////////////////////////////////
277f0a14 7947TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3 const * const vertexpos[4] , const Double_t* width,
b671cde1 7948 Double_t height, const char* shapename, Int_t isign) const{
44285dfa 7949 /////////////////////////////////////////////////////////////
7950 // Method generating an Arb shape
7951 /////////////////////////////////////////////////////////////
7952 const Int_t kvertexnumber = 8;
7953 const Int_t ktransvectnumber = 2;
b671cde1 7954 TVector3 vertex[kvertexnumber];
7955 TVector3 transvector[2];
7956 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
44285dfa 7957 /////////////////////////////////////////////////////////////
d7599219 7958 //Setting the vertices for TGeoArb8
44285dfa 7959 /////////////////////////////////////////////////////////////
b671cde1 7960 vertex[0] = *vertexpos[0];
7961 vertex[1] = *vertexpos[1];
7962 vertex[2] = vertex[1];
7963 vertex[3] = vertex[0];
7964 vertex[4] = *vertexpos[2];
7965 vertex[5] = *vertexpos[3];
7966 vertex[6] = vertex[5];
7967 vertex[7] = vertex[4];
7968
7969 // NB: order of points is clockwise
7970 if (isign < 0) {
7971 vertex[2] -= transvector[0];
7972 vertex[3] -= transvector[0];
7973 vertex[6] -= transvector[1];
7974 vertex[7] -= transvector[1];
7975 }
7976 else {
7977 vertex[0] += transvector[0];
7978 vertex[1] += transvector[0];
7979 vertex[4] += transvector[1];
7980 vertex[5] += transvector[1];
7981 }
7982
44285dfa 7983 /////////////////////////////////////////////////////////////
7984 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
b671cde1 7985 for(Int_t i = 0; i<kvertexnumber;i++) {
7986 arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
7987 }
7988
44285dfa 7989 return arbshape;
d7599219 7990}
bf210566 7991///////////////////////////////////////////////////////////////////////////////
7992TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
7993 Double_t rmax, Int_t nedges, Double_t height){
7994 /////////////////////////////////////////////////////////////
7995 // Method generating Arc shape
7996 /////////////////////////////////////////////////////////////
7997 const Int_t kvertexnumber = 2*nedges+2;
7998 TGeoXtru* arcshape = new TGeoXtru(2);
7999 TVector3** vertexposition[2];
8000 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8001 Double_t angle = 0.;
8002 for(Int_t i=0; i<nedges+1; i++){
8003 angle = 90.+0.5*phi-i*(phi/nedges);
8004 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
8005 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
8006 }
8007 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8008 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8009 for(Int_t i=0; i<kvertexnumber; i++){
8010 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8011 yvertexpoints[i] = vertexposition[0][i]->Y();
8012 }
8013 else if(i>=1&&i<nedges+2)
8014 {
8015 xvertexpoints[i] = vertexposition[1][i-1]->X();
8016 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8017 }
8018 else
8019 {
8020 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8021 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8022 }
8023 }
8024 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8025 arcshape->DefineSection(0,-0.5*height);
8026 arcshape->DefineSection(1,0.5*height);
44285dfa 8027 /////////////////////////////////////////////////////////////
bf210566 8028 // Deallocating memory
44285dfa 8029 /////////////////////////////////////////////////////////////
bf210566 8030 for(Int_t i=0; i<2; i++){
8031 for(Int_t j=0; j<nedges+1; j++)
8032 delete vertexposition[i][j];
8033 delete [] vertexposition[i];
8034 }
8035 delete [] xvertexpoints;
8036 delete [] yvertexpoints;
8037 /////////////////////////////////////////////////////////////
8038 return arcshape;
d7599219 8039}
8040////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8041TGeoShape* AliITSv11GeometrySSD::GetScrewShape(const Double_t* radius,const Int_t* edgesnumber,const Double_t* section) const {
9b0c60ab 8042 ///////////////////////////////////////////////////////////////////////
8043 // Method Generating the Screw Shape
8044 // radius[0]: outer radius
8045 // radius[1]: inner radius
8046 // edgesnumber[0]: outer number of edges
8047 // edgesnumber[1]: inner number of edges
8048 // section[0]: lower section position
8049 // section[1]: higher section position
8050 ///////////////////////////////////////////////////////////////////////
8051 Double_t outradius = radius[0];
8052 Double_t inradius = radius[1];
8053 Int_t outvertexnumber = edgesnumber[0];
8054 Int_t invertexnumber = edgesnumber[1];
851c0ce3 8055 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8056 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8057 for(Int_t i=0; i<outvertexnumber; i++){
9b0c60ab 8058 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8059 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8060 }
851c0ce3 8061 for(Int_t i=0; i<invertexnumber; i++){
8062 xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8063 yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
9b0c60ab 8064 }
851c0ce3 8065 TGeoXtru* screwshapeout = new TGeoXtru(2);
8066 screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8067 screwshapeout->DefineSection(0,section[0]);
8068 screwshapeout->DefineSection(1,section[1]);
8069 TGeoXtru* screwshapein = new TGeoXtru(2);
8070 screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8071 screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8072 screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8073 TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8074 TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8075
9b0c60ab 8076 delete [] xscrewvertex;
8077 delete [] yscrewvertex;
8078 return screwshape;
8079}
8080////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8081TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, const Double_t *section) const {
9b0c60ab 8082 ///////////////////////////////////////////////////////////////////////
8083 // Method Generating the Hole Shape
8084 // radius of the Hole
8085 // nedges: number of edges to approximate the circle
8086 ///////////////////////////////////////////////////////////////////////
851c0ce3 8087 Double_t* xholevertex = new Double_t[nedges];
8088 Double_t* yholevertex = new Double_t[nedges];
8089 Double_t z = 0.5*(section[0]+section[1]);
8090 Double_t dz = 0.5*(section[1]-section[0]);
8091 TGeoTranslation *tr = 0;
8092 if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8093 tr = new TGeoTranslation(0.,0.,z);
8094 tr->RegisterYourself();
8095 }
8096 TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8097 for(Int_t i=0; i<nedges; i++){
8098 xholevertex[i] = radius*CosD(i*360./nedges);
8099 yholevertex[i] = radius*SinD(i*360./nedges);
9b0c60ab 8100 }
851c0ce3 8101 TGeoXtru* holeshapeout = new TGeoXtru(2);
8102 holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8103 holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8104 holeshapeout->DefineSection(1,section[1]+0.01);
8105 TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8106 TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8107
9b0c60ab 8108 delete [] xholevertex;
8109 delete [] yholevertex;
8110 return holeshape;
8111}
8112////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8113TVector3* AliITSv11GeometrySSD::GetReflection(const TVector3* vector,const Double_t* param) const{
44285dfa 8114 /////////////////////////////////////////////////////////////
8115 // Given an axis specified by param, it gives the reflection of the point
8116 // respect to the axis
8117 /////////////////////////////////////////////////////////////
8118 TVector3* n = new TVector3(param[0],param[1],param[2]);
8119 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8120 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 8121 /////////////////////////////////////////////////////////////
8122 // Deallocating memory
8123 /////////////////////////////////////////////////////////////
8124 delete n;
8125 /////////////////////////////////////////////////////////////
44285dfa 8126 return reflectedvector;
d7599219 8127}
8128////////////////////////////////////////////////////////////////////////////////
f510fd70 8129TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(const TGeoHMatrix* ct,
d7599219 8130 Double_t dx,
8131 Double_t dy,
8132 Double_t dz) const{
44285dfa 8133 /////////////////////////////////////////////////////////////
d7599219 8134 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 8135 /////////////////////////////////////////////////////////////
bf210566 8136 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8137 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 8138 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 8139 hmatrix->SetTranslation(newvect);
8140 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8141 delete hmatrix;
8142 return matrix;
d7599219 8143}
8144////////////////////////////////////////////////////////////////////////////////
d7599219 8145TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 8146 /////////////////////////////////////////////////////////////
8147 // Method returning the Medium type
8148 /////////////////////////////////////////////////////////////
a3f8715e 8149 char ch[100];
045be90c 8150 snprintf(ch,100, "ITS_%s",mediumName);
d7599219 8151 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8152 if (! medium)
160835d5 8153 AliError(Form("medium %s not found !\n", mediumName));
d7599219 8154 return medium;
8155}
8156////////////////////////////////////////////////////////////////////////////////
d7599219 8157void AliITSv11GeometrySSD::CreateMaterials(){
8158///////////////////////////////////
8159// This part has to be modified
8160///////////////////////////////////
8161 ///////////////////////////////////
8162 // Silicon for Sensor
8163 ///////////////////////////////////
bf210566 8164 fSSDSensorMedium = GetMedium("SI$");
d7599219 8165 ///////////////////////////////////
8166 // Silicon Mixture for Sensor
8167 ///////////////////////////////////
44285dfa 8168 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8169 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 8170 ///////////////////////////////////
8171 // Stiffener Components Materials
8172 ///////////////////////////////////
bf210566 8173 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 8174 ///////////////////////////
8175 // Stiffener Connectors
8176 ///////////////////////////
bf210566 8177 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 8178 ////////////////////////////////
8179 // Stiffener 0603-1812 Capacitor
8180 ////////////////////////////////
bf210566 8181 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8182 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
78e34526 8183 fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$");
d7599219 8184 ///////////////////////////
8185 // Stiffener Hybrid Wire
8186 ///////////////////////////
bf210566 8187 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 8188 ///////////////////////////
8189 // Al for Cooling Block
8190 ///////////////////////////
bf210566 8191 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 8192 //////////////////////////////////////////////////////
8193 // Kapton and Al for Chip Cable Flex and Ladder Cables
8194 //////////////////////////////////////////////////////
bf210566 8195 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8196 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8197 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8198 fSSDAlTraceFlexMedium = GetMedium("AL$");
8199 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8200 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 8201 /////////////////////////////////////////////////////////////////
8202 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8203 //////////////////////////////////////////////////////////////////
44285dfa 8204 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 8205 /////////////////////////////////////////////////////////////////
8206 // G10 for Detector Leg, TubeHolder
8207 //////////////////////////////////////////////////////////////////
44285dfa 8208 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8209 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8210 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8211 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 8212 /////////////////////////////////////////////////////////////////
8213 // Water and Phynox for Cooling Tube
8214 //////////////////////////////////////////////////////////////////
bf210566 8215 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 8216 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 8217 /////////////////////////////////////////////////////////////////////
9b0c60ab 8218 // Material for Support Rings
8219 /////////////////////////////////////////////////////////////////////
8220 fSSDSupportRingAl = GetMedium("AL$");
47f8de53 8221 fSSDRohaCellCone = GetMedium("ROHACELL$");
9b0c60ab 8222 /////////////////////////////////////////////////////////////////////
bf210566 8223 fSSDAir = GetMedium("SDD AIR$");
47f8de53 8224 fSSDCopper = GetMedium("COPPER$");
78e34526 8225 fSSDSn = GetMedium("Sn$");
bf210566 8226 fCreateMaterials = kTRUE;
d7599219 8227}
8228/////////////////////////////////////////////////////////////////////
277f0a14 8229