]> 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
Fixing a little memory leak
[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;
f7cd318e 526
47f8de53 527/////////////////////////////////////////////////////////////////////////////////
44285dfa 528ClassImp(AliITSv11GeometrySSD)
529/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 530AliITSv11GeometrySSD::AliITSv11GeometrySSD():
531 AliITSv11Geometry(),
44285dfa 532 fSSDChipMedium(),
533 fSSDChipGlueMedium(),
534 fSSDStiffenerMedium(),
535 fSSDStiffenerConnectorMedium(),
536 fSSDStiffener0603CapacitorMedium(),
537 fSSDStiffener1812CapacitorMedium(),
78e34526 538 fSSDStiffenerCapacitorCapMedium(),
44285dfa 539 fSSDStiffenerHybridWireMedium(),
540 fSSDKaptonFlexMedium(),
541 fSSDAlTraceFlexMedium(),
542 fSSDAlTraceLadderCableMedium(),
543 fSSDKaptonLadderCableMedium(),
544 fSSDKaptonChipCableMedium(),
545 fSSDAlTraceChipCableMedium(),
546 fSSDAlCoolBlockMedium(),
547 fSSDSensorMedium(),
548 fSSDSensorSupportMedium(),
549 fSSDCarbonFiberMedium(),
550 fSSDTubeHolderMedium(),
551 fSSDCoolingTubeWater(),
552 fSSDCoolingTubePhynox(),
9b0c60ab 553 fSSDSupportRingAl(),
44285dfa 554 fSSDMountingBlockMedium(),
47f8de53 555 fSSDRohaCellCone(),
bf210566 556 fSSDAir(),
47f8de53 557 fSSDCopper(),
78e34526 558 fSSDSn(),
bf210566 559 fCreateMaterials(kFALSE),
560 fTransformationMatrices(kFALSE),
561 fBasicObjects(kFALSE),
562 fcarbonfiberjunction(),
563 fcoolingtubesupport(),
564 fhybridmatrix(),
565 fssdcoolingblocksystem(),
566 fcoolingblocksystematrix(),
567 fssdstiffenerflex(),
568 fssdendflex(),
cd2243fb 569 fcoolingtube(0),
9b0c60ab 570 fendladdercoolingtubesupportmatrix(),
bf210566 571 fendladdermountingblock(),
9b0c60ab 572 fendladdermountingblockclip(),
bf210566 573 fSSDSensor5(),
574 fSSDSensor6(),
575 fSSDLayer5(),
576 fSSDLayer6(),
577 fMotherVol(),
9b0c60ab 578 fLay5LadderSupportRing(),
579 fLay6LadderSupportRing(),
e5bf64ae 580 fgkEndCapSupportSystem(),
47f8de53 581 fSSDCone(),
44285dfa 582 fColorCarbonFiber(4),
583 fColorRyton(5),
bf210566 584 fColorPhynox(14),
44285dfa 585 fColorSilicon(3),
bf210566 586 fColorAl(38),
78e34526 587 fColorNiSn(40),
44285dfa 588 fColorKapton(6),
589 fColorPolyhamide(5),
590 fColorStiffener(9),
bf210566 591 fColorEpoxy(30),
592 fColorWater(7),
593 fColorG10(41)
44285dfa 594{
595 ////////////////////////
596 // Standard constructor
597 ////////////////////////
705f5cb5 598 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++){
599 fendladdermountingblockcombitrans[i] = NULL;
600 }
045be90c 601 for (Int_t i=0; i < fgkcarbonfibersupportnumber; i++) {
602 fcarbonfibersupport[i] = 0;
603 fcarbonfibersupportmatrix[i] = 0;
604 }
605 for (Int_t i=0; i < fgkcarbonfiberjunctionumber; i++) {
606 fcarbonfiberjunctionmatrix[i] = 0;
607 }
608 for (Int_t i=0; i < fgkcarbonfiberlowersupportnumber; i++) {
609 fcarbonfiberlowersupport[i] = 0;
610 fcarbonfiberlowersupportrans[0] = 0;
611 }
612 for (Int_t i=0; i < fgkvolumekind; i++) {
613 fssdsensorsupport[i] = 0;
614 }
615 for (Int_t i=0; i < fgkssdsensorsupportnumber; i++) {
616 fssdsensorsupportmatrix[i] = 0;
617 }
618 for (Int_t i=0; i < fgkcoolingtubesupportnumber; i++) {
619 fcoolingtubesupportmatrix[i] = 0;
620 }
621 for (Int_t i=0; i < fgkhybridcompnumber; i++) {
622 fssdhybridcomponent[i] = 0;
623 }
624 for (Int_t i=0; i < fgkcoolingblocknumber; i++) {
625 fcoolingblockmatrix[i] = 0;
626 }
627 for (Int_t i=0; i < fgkflexnumber; i++) {
628 fstiffenerflexmatrix[i] = 0;
629 fendflexmatrix[i] = 0;
630 }
631 for (Int_t i=0; i < fgkendladdercoolingtubenumber; i++) {
632 fendladdercoolingtube[i] = 0;
633 for (Int_t j = 0; j < 2; j++)
634 fendladdercoolingtubematrix[i][j] = 0;
635 }
636 for (Int_t i=0; i < fgkendlabbercarbonfiberjunctionumber; i++) {
637 fendladdercarbonfiberjunction[i] = 0;
638 }
b28b5356 639 for (Int_t i=0; i < fgkendladdercarbonfiberjunctionmatrixnumber; i++) {
045be90c 640 fendladdercarbonfiberjunctionmatrix[i] = 0;
641 }
642 for (Int_t i=0; i < fgkendladdercarbonfibermatrixnumber; i++) {
643 fendladdercarbonfibermatrix[i] = 0;
644 }
645 for (Int_t i=0; i < fgkendladdermountingblocknumber; i++) {
646 fendladdermountingblockclipmatrix[i] = 0;
647 }
648 for (Int_t i = 0; i < fgkendladderlowersuppnumber+1; i++) {
649 fendladderlowersupptrans[i] = 0;
650 }
651 for (Int_t i = 0; i < fgkladdercablesnumber; i++) {
652 fladdercablematrix[i] = 0;
653 }
654 for (Int_t i = 0; i < fgkladdersegmentnumber; i++) {
655 fladdersegment[i] = 0;
656 }
657 for (Int_t i = 0; i < fgkladdernumber; i++) {
658 fladder[i] = 0;
659 fladdermatrix[i] = 0;
660 fssdsensormatrix[i] = 0;
661 flayermatrix[i] = 0;
662 }
663 for (Int_t i = 0; i < 2; i++) {
664 fLay5LadderSupport[i] = 0;
665 fLay6LadderSupport[i] = 0;
705f5cb5 666 fcoolingtubematrix[i] = NULL;
667 fendladdersegment[i] = NULL;
668 fendladdersegmentmatrix[i] = NULL;
045be90c 669 }
44285dfa 670}
705f5cb5 671
bf210566 672///////////////////////////////////////////////////////////////////////////////
673void AliITSv11GeometrySSD::CreateTransformationMatrices(){
674 ///////////////////////////////////////////////////////////////////////
675 // Method generating the trasformation matrix for the whole SSD Geometry
676 ///////////////////////////////////////////////////////////////////////
677 // Setting some variables for Carbon Fiber Supportmatrix creation
678 //////////////////////////////////////////////////////////////////////
679 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
680 * CosD(fgkCarbonFiberJunctionAngle[0]);
681 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
682 + fgkCarbonFiberSupportTopEdgeDist[0]
683 + fgkCarbonFiberSupportWidth);
684 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
685 * TanD(fgkCarbonFiberJunctionAngle[0]);
686 TGeoRotation* carbonfiberot[3];
687 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
688 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
689 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
690 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
691 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
692 * CosD(fgkCarbonFiberTriangleAngle),0.,
693 - fgkCarbonFiberTriangleLength
694 * SinD(fgkCarbonFiberTriangleAngle)};
695 ///////////////////////////////////////////
696 //Setting Local Translations and Rotations:
697 ///////////////////////////////////////////
698 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
699 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
700 0.5*carbonfibersupportheight,NULL);
701 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
702 2.*symmetryplaneposition+transvector[1],
703 transvector[2], carbonfiberot[2]);
704 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
705 /////////////////////////////////////////////////////////////
706 // Carbon Fiber Support Transformations
707 /////////////////////////////////////////////////////////////
708 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
709 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
710 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
711 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
712 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
713 }
714 /////////////////////////////////////////////////////////////
715 // Carbon Fiber Junction Transformation
716 /////////////////////////////////////////////////////////////
717 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
718 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
719 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
720 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
721 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
722 localcarbonfiberjunctionmatrix[i] =
723 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
724 localcarbonfiberjunctionrot[i] =
725 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
726 localcarbonfiberjunctiontrans[i] =
727 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 728 }
bf210566 729 ///////////////////////
730 // Setting Translations
731 ///////////////////////
732 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
733 localcarbonfiberjunctiontrans[1][0] =
734 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
735 localcarbonfiberjunctiontrans[2][0] =
736 new TGeoTranslation(fgkCarbonFiberTriangleLength
737 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
738 fgkCarbonFiberTriangleLength
739 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
740 localcarbonfiberjunctiontrans[0][1] =
741 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
742 localcarbonfiberjunctiontrans[1][1] =
743 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
744 localcarbonfiberjunctiontrans[2][1] =
745 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
746 ////////////////////
747 // Setting Rotations
748 ////////////////////
749 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
750 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
751 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
752 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
753 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
754 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
755 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
756 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
757 ////////////////////////////////////////
758 // Setting Carbon Fiber Junction matrix
759 ////////////////////////////////////////
760 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
761 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
762 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
763 localcarbonfiberjunctionmatrix[i][j] =
764 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
765 *localcarbonfiberjunctionrot[i][j]);
766 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
767 }
d7599219 768 }
bf210566 769 /////////////////////////////////////////////////////////////
770 // Carbon Fiber Lower Support Transformations
771 /////////////////////////////////////////////////////////////
772 TGeoTranslation* localcarbonfiberlowersupportrans[2];
773 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
774 fgkCarbonFiberLowerSupportVolumePosition[1]
775 + fgkCarbonFiberLowerSupportVolumePosition[0],
776 0.0);
777 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
778 fgkCarbonFiberJunctionWidth
779 - fgkCarbonFiberLowerSupportWidth
780 - fgkCarbonFiberLowerSupportVolumePosition[0]
781 - fgkCarbonFiberLowerSupportVolumePosition[1],
782 - 0.5*fgkCarbonFiberLowerSupportHeight);
783 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
784 fcarbonfiberlowersupportrans[0] =
785 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
786 fcarbonfiberlowersupportrans[1] =
787 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
788 /////////////////////////////////////////////////////////////
789 // SSD Sensor Support Transformations
790 /////////////////////////////////////////////////////////////
791 const Int_t kssdsensorsupportmatrixnumber = 3;
792 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
793 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
794 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
795 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
796 localssdsensorsupportmatrix[i] =
797 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
798 localssdsensorsupportrot[i] =
799 new TGeoRotation*[kssdsensorsupportmatrixnumber];
800 localssdsensorsupportrans[i] =
801 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 802 }
bf210566 803 ///////////////////////
804 // Setting Translations
805 ///////////////////////
806 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
807 0.5*fgkSSDSensorSideSupportWidth,
808 0.0);
809 localssdsensorsupportrans[1][0] =
810 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
811 localssdsensorsupportrans[2][0] =
812 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
813 localssdsensorsupportrans[0][1] =
814 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
815 0.5*fgkSSDSensorSideSupportThickness[0],
816 0.0);
817 localssdsensorsupportrans[1][1] =
818 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
819 - 0.5*fgkSSDSensorSideSupportThickness[0]
820 - fgkSSDModuleSensorSupportDistance,
821 0.0);
822 localssdsensorsupportrans[2][1] =
823 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
824 - fgkSSDSensorCenterSupportPosition,
825 0.5*fgkSSDSensorCenterSupportWidth
826 - 0.5*fgkSSDModuleSensorSupportDistance,
827 fgkSSDSensorCenterSupportThickness[0]);
828 localssdsensorsupportrans[0][2] =
829 new TGeoTranslation(fgkCarbonFiberTriangleLength
830 + fgkCarbonFiberJunctionToSensorSupport,
831 fgkCarbonFiberJunctionWidth
832 - 0.5*(fgkCarbonFiberLowerSupportWidth
833 + fgkSSDSensorCenterSupportLength
834 - fgkSSDSensorCenterSupportThickness[0])
835 - fgkSSDSensorCenterSupportPosition,
836 0.0);
837 localssdsensorsupportrans[1][2] =
838 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
839 localssdsensorsupportrans[2][2] =
840 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
841 ////////////////////
842 // Setting Rotations
843 ////////////////////
844 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
845 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
846 localssdsensorsupportrot[i][j] = new TGeoRotation();
847 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
848 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
849 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 850 }
bf210566 851 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
852 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
853 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
854 ////////////////////////////////////////
855 // SSD Sensor Support matrix
856 ////////////////////////////////////////
857 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
858 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
859 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
860 localssdsensorsupportmatrix[i][j] =
861 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
862 *localssdsensorsupportrot[i][j]);
863 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
864 }
d7599219 865 }
44285dfa 866 /////////////////////////////////////////////////////////////
bf210566 867 // SSD Cooling Tube Support Transformations
44285dfa 868 /////////////////////////////////////////////////////////////
bf210566 869 const Int_t kcoolingtubesupportmatrixnumber = 2;
870 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
871 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
872 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 873 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 874 /fgkCoolingTubeSupportRmax);
bf210566 875 localcoolingtubesupportrans[0] =
876 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 877 + 2.*(fgkCoolingTubeSupportLength
44285dfa 878 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 879 + fgkCarbonFiberTriangleLength
bf210566 880 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
881 localcoolingtubesupportrans[1] =
882 new TGeoTranslation(fgkCarbonFiberJunctionLength
883 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
884 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
885 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
886 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
887 - 0.5*(fgkCarbonFiberLowerSupportWidth
888 + fgkSSDSensorCenterSupportLength
889 - fgkSSDSensorCenterSupportThickness[0])
890 + 0.5*fgkSSDSensorLength,
891 - 0.5*fgkCoolingTubeSupportHeight);
892 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
893 localcoolingtubesupportrot[i] = new TGeoRotation();
894 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
895 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
896 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
897 localcoolingtubesupportmatrix[i] =
898 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
899 *localcoolingtubesupportrot[i]);
900 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
901 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
902 (*localcoolingtubesupportmatrix[0]));
903 /////////////////////////////////////////////////////////////
9b0c60ab 904 // End Ladder SSD Cooling Tube Support Transformations
905 /////////////////////////////////////////////////////////////
906 TGeoTranslation** localendladdercooltubetrans[2];
907 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
908 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
909 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
910 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
911 - (fgkCoolingTubeSupportLength
912 - fgkCoolingTubeSupportRmax),
913 fgkEndLadderMountingBlockPosition[0]
914 - fgkendladdercoolingsupportdistance[0]
915 + 0.5*fgkCoolingTubeSupportWidth,
916 - 0.5*fgkCoolingTubeSupportHeight);
917 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
918 - (fgkCoolingTubeSupportLength
919 - fgkCoolingTubeSupportRmax),
920 fgkEndLadderMountingBlockPosition[0]
921 + fgkendladdercoolingsupportdistance[1]
922 + 0.5*fgkCoolingTubeSupportWidth,
923 - 0.5*fgkCoolingTubeSupportHeight);
924 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
925 - fgkCoolingTubeSupportRmax)
926 + fgkCarbonFiberTriangleLength
927 - 2.0*fgkCarbonFiberJunctionLength,
928 0.0,
929 0.0);
930 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
931 fgkendladdercoolingsupportdistance[0]
932 + fgkendladdercoolingsupportdistance[1],
933 0.0);
934 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
935 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
936 + fgkCarbonFiberJunctionLength
937 - fgkCoolingTubeSupportLength,
938 fgkEndLadderCarbonFiberLowerJunctionLength[1]
939 - 0.5*fgkCoolingTubeSupportWidth
940 -fgkendladdercoolingsupportdistance[2],
941 - 0.5*fgkCoolingTubeSupportHeight);
942 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
943 + fgkCoolingTubeSupportLength
944 - fgkCoolingTubeSupportRmax
945 - fgkCarbonFiberJunctionLength,
946 fgkEndLadderCarbonFiberLowerJunctionLength[1]
947 - 0.5*fgkCoolingTubeSupportWidth
948 - fgkendladdercoolingsupportdistance[2],
949 - 0.5*fgkCoolingTubeSupportHeight);
950 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
951 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
952 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
953 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
954 (*localcoolingtubesupportrot[1]));
955 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
956 (*localcoolingtubesupportrot[1]));
957 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
958 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
959 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
960 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
961 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
962
963 fendladdercoolingtubesupportmatrix[1][0] =
964 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
965 *(*localcoolingtubesupportrot[1]));
966 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
967 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
968 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
969 /////////////////////////////////////////////////////////////
bf210566 970 // SSD Cooling Tube Transformations
971 /////////////////////////////////////////////////////////////
972 TGeoRotation* localcoolingtuberot = new TGeoRotation();
973 localcoolingtuberot->SetAngles(0.,90.,0.);
cd2243fb 974 TGeoTranslation* localcoolingtubetrans[2];
975 TVector3* localcoolingtubevect[2];
976
977 localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
bf210566 978 -fgkCarbonFiberTriangleLength),
cd2243fb 979 fgkCarbonFiberJunctionWidth // Y-coord is local Z, from sensor translation
980 - fgkCarbonFiberLowerSupportWidth
981 - fgkLowerSupportToSensorZ ,
bf210566 982 - 0.5*fgkCoolingTubeSupportHeight);
cd2243fb 983 localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
984 localcoolingtubevect[0]->Y(),
985 localcoolingtubevect[0]->Z());
78e34526 986 for(Int_t j=0; j<2; j++){
987 localcoolingtubetrans[j] =
988 new TGeoTranslation(localcoolingtubevect[j]->X(),
989 localcoolingtubevect[j]->Y(),
990 localcoolingtubevect[j]->Z());
991 fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j])
992 *(*localcoolingtuberot));
993 }
bf210566 994 /////////////////////////////////////////////////////////////
9b0c60ab 995 // SSD End Ladder Cooling Tube Transformations
996 /////////////////////////////////////////////////////////////
997 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
998 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
999 TGeoTranslation** localendlladdercoolingtubetrans[2];
cd2243fb 1000 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
1001 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
9b0c60ab 1002 for(Int_t i=0; i<2; i++)
cd2243fb 1003 for(Int_t j=0; j<2; j++)
9b0c60ab 1004 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
cd2243fb 1005
1006 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
9b0c60ab 1007 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1008 - fgkCoolingTubeSupportRmax)
1009 + fgkCarbonFiberJunctionLength,
cd2243fb 1010 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
9b0c60ab 1011 - 0.5*fgkCoolingTubeSupportHeight);
1012 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1013 - fgkCoolingTubeSupportRmax)
1014 - fgkCarbonFiberJunctionLength
1015 + fgkCarbonFiberTriangleLength,
cd2243fb 1016 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
9b0c60ab 1017 - 0.5*fgkCoolingTubeSupportHeight);
cd2243fb 1018
9b0c60ab 1019 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
cd2243fb 1020 - fgkCoolingTubeSupportRmax)
1021 + fgkCarbonFiberJunctionLength,
1022 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
9b0c60ab 1023 - 0.5*fgkCoolingTubeSupportHeight);
1024 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1025 - fgkCoolingTubeSupportRmax)
1026 - fgkCarbonFiberJunctionLength
1027 + fgkCarbonFiberTriangleLength,
cd2243fb 1028 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
9b0c60ab 1029 - 0.5*fgkCoolingTubeSupportHeight);
9b0c60ab 1030 for(Int_t i=0; i<2; i++)
cd2243fb 1031 for(Int_t j=0; j<2; j++){
9b0c60ab 1032 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1033 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1034 }
1035 /////////////////////////////////////////////////////////////
bf210566 1036 // SSD Hybrid Components Transformations
1037 /////////////////////////////////////////////////////////////
1038 const Int_t khybridmatrixnumber = 3;
1039 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1040 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1041 0.5*fgkSSDStiffenerWidth,
1042 0.5*fgkSSDStiffenerHeight);
1043 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1044 fgkSSDModuleStiffenerPosition[1],0.0);
1045
1046 localhybridtrans[2] = new TGeoTranslation(
1047 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1048 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1049 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1050 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1051 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1052 - fgkSSDSensorCenterSupportThickness[0]),
1053 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
ca86fdb4 1054 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
0fb26117 1055 - fgkSSDModuleVerticalDisalignment));
bf210566 1056 fhybridmatrix = new TGeoHMatrix();
1057 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1058 /////////////////////////////////////////////////////////////
1059 // SSD Cooling Block Transformations
1060 /////////////////////////////////////////////////////////////
78e34526 1061 TGeoTranslation localcoolingblocktrans (fcoolingtubematrix[0]->GetTranslation()[0]
1062 - 0.5*fgkSSDCoolingBlockLength,
1063 fhybridmatrix->GetTranslation()[1]-0.5*fgkSSDStiffenerWidth,
1064 fhybridmatrix->GetTranslation()[2]+0.5*fgkSSDStiffenerHeight+
1065 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1066 fcoolingblocksystematrix = new TGeoHMatrix(localcoolingblocktrans);
bf210566 1067 /////////////////////////////////////////////////////////////
1068 // SSD Stiffener Flex Transformations
1069 /////////////////////////////////////////////////////////////
1070 const Int_t klocalflexmatrixnumber = 4;
1071 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1072 for(Int_t i=0; i<fgkflexnumber; i++)
1073 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1074 for(Int_t i=0; i<fgkflexnumber; i++)
1075 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1076 localflexmatrix[i][j] = new TGeoCombiTrans();
1077 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1078 - 2.*fgkSSDModuleStiffenerPosition[1]
1079 - fgkSSDStiffenerWidth;
1080 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1081 +0.5*fgkSSDStiffenerLength,
1082 0.5*fgkSSDStiffenerWidth,
1083 -0.5*fgkSSDStiffenerHeight
1084 -0.5*fgkSSDFlexHeight[0]);
1085 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1086 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1087 -0.5*fgkSSDStiffenerWidth,
1088 -0.5*fgkSSDStiffenerHeight
1089 -0.5*fgkSSDFlexHeight[0]);
1090 TGeoRotation* localflexrot = new TGeoRotation();
1091 localflexrot->SetAngles(180.,0.,0.);
1092 localflexmatrix[1][0]->SetRotation(localflexrot);
1093 for(Int_t i=0; i<fgkflexnumber; i++)
1094 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1095 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1096 for(Int_t i=0; i<fgkflexnumber; i++){
1097 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1098 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1099 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1100 }
bf210566 1101 /////////////////////////////////////////////////////////////
1102 // SSD End Flex Transformations
1103 /////////////////////////////////////////////////////////////
1104 TGeoRotation* localendflexrot = new TGeoRotation();
1105 localendflexrot->SetAngles(0.0,90.0,0.0);
1106 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1107 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1108 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1109 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1110 * TMath::DegToRad()*ssdflexradiusmax
1111 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 1112 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1113 - 0.1*fgkSSDFlexFullLength;
bf210566 1114 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1115 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1116 + fgkSSDFlexLength[2];
1117 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1118 0.5*fgkSSDFlexWidth[0],
1119 2.*fgkSSDStiffenerHeight
1120 + 0.5*fgkSSDFlexHeight[0]);
1121 localendflexmatrix->SetRotation(localendflexrot);
1122 for(Int_t i=0; i<fgkflexnumber; i++)
1123 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1124 /////////////////////////////////////////////////////////////
1125 // End Ladder Carbon Fiber Junction
1126 /////////////////////////////////////////////////////////////
1127 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1128 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1129 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1130 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1131 localendladdercarbonfiberjunctionmatrix[i]
b28b5356 1132 = new TGeoCombiTrans*[fgkendladdercarbonfiberjunctionmatrixnumber];
bf210566 1133 localendladdercarbonfiberjunctionrot[i]
b28b5356 1134 = new TGeoRotation*[fgkendladdercarbonfiberjunctionmatrixnumber];
bf210566 1135 localendladdercarbonfiberjunctiontrans[i]
b28b5356 1136 = new TGeoTranslation*[fgkendladdercarbonfiberjunctionmatrixnumber];
bf210566 1137 fendladdercarbonfiberjunctionmatrix[i]
b28b5356 1138 = new TGeoHMatrix*[fgkendladdercarbonfiberjunctionmatrixnumber];
d7599219 1139 }
bf210566 1140 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
b28b5356 1141 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
bf210566 1142 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1143 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1144 }
1145 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
b28b5356 1146 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
bf210566 1147 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1148 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1149 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1150 0.0,0.0);
1151 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1152 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1153 * SinD(fgkCarbonFiberTriangleAngle),
1154 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1155 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1156 }
1157 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1158 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1159 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1160 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1161 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1162 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1163 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1164 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1165 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1166 localendladdercarbonfiberjunctionglobalmatrix[i] =
1167 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1168 *localendladdercarbonfiberjunctionglobalrot[i]);
1169 }
1170 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
b28b5356 1171 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
bf210566 1172 localendladdercarbonfiberjunctionmatrix[i][j] =
1173 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1174 *localendladdercarbonfiberjunctionrot[i][j]);
1175 fendladdercarbonfiberjunctionmatrix[i][j] =
1176 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1177 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1178 }
1179 /////////////////////////////////////////////////////////////
1180 // End Ladder Carbon Fiber Support
1181 /////////////////////////////////////////////////////////////
1182 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1183 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1184 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1185 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1186 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1187 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1188 }
1189 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1190 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1191 fendladdercarbonfibermatrix[i][j] =
1192 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1193 *(*fcarbonfibersupportmatrix[j]));
1194 /////////////////////////////////////////////////////////////
1195 // End Ladder SSD Mounting Block
1196 /////////////////////////////////////////////////////////////
1197 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1198 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1199 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1200 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1201 + fgkSSDMountingBlockLength[1])
1202 + 0.5*fgkCarbonFiberTriangleLength,
1203 fgkEndLadderMountingBlockPosition[i],
1204 - fgkSSDMountingBlockHeight[1]
1205 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1206 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1207 endladdermountingblockrot->SetAngles(0.,90.,0.);
1208 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1209 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1210 /////////////////////////////////////////////////////////////
1211 // End Ladder SSD Mounting Block Clip Matrix
1212 /////////////////////////////////////////////////////////////
1213 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1214 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1215
1216 TGeoRotation* localendladdercliprot = new TGeoRotation();
1217 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1218 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1219 - fgkSSDMountingBlockLength[1])
1220 + fgkSSDMountingBlockLength[0],0.,0.);
1221 localendladdercliprot->SetAngles(90.,180.,-90.);
1222 TGeoCombiTrans* localendladderclipcombitrans =
1223 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1224 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1225 for(Int_t j=0; j<2; j++){
1226 fendladdermountingblockclipmatrix[i][j] =
1227 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1228 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1229 }
bf210566 1230 /////////////////////////////////////////////////////////////
1231 // End Ladder Carbon Fiber Lower Support
1232 /////////////////////////////////////////////////////////////
1233 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1234 fendladderlowersupptrans[i] =
1235 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1236 + 0.5*fgkSSDMountingBlockWidth),
1237 - 0.5*fgkCarbonFiberLowerSupportHeight);
5d9d4033 1238 fendladderlowersupptrans[0]->SetDz(-0.5*fgkCarbonFiberLowerSupportHeight-fgkSSDTolerance);
bf210566 1239 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1240 fgkCarbonFiberLowerSupportVolumePosition[1]
1241 + fgkCarbonFiberLowerSupportVolumePosition[0],
1242 0.0);
1243 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1244 /////////////////////////////////////////////////////////////
1245 // Matrix for positioning Ladder into mother volume
1246 /////////////////////////////////////////////////////////////
1247 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1248 for(Int_t i=0; i<fgkladdernumber; i++)
1249 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1250 TGeoRotation* localladdermotherrot = new TGeoRotation();
1251 localladdermotherrot->SetAngles(0.,90.,0.);
1252 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1253 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1254 for(Int_t i=0; i<fgkladdernumber; i++){
1255 localladdermothertrans[i] = new TGeoTranslation(0.,
1256 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1257 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1258 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1259 * fgkCarbonFiberJunctionWidth,0.);
1260 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1261 *localladdermotherrot);
1262 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1263 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1264 }
44285dfa 1265 /////////////////////////////////////////////////////////////
bf210566 1266 // Ladder Cables Matrices
44285dfa 1267 /////////////////////////////////////////////////////////////
44285dfa 1268 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1269 + fgkSSDFlexHeight[1];
44285dfa 1270 Double_t ssdladdercabletransx[3];
1271 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1272 * SinD(2.*fgkSSDFlexAngle)
1273 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1274 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1275 - ssdladdercabletransx[0]
bf210566 1276 / SinD(2.*fgkSSDFlexAngle))
1277 * CosD(fgkSSDFlexAngle);
44285dfa 1278 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1279 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1280 - fgkSSDFlexLength[2]-TMath::Pi()
1281 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1282 - fgkSSDLadderCableWidth)
bf210566 1283 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1284 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1285 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1286 ssdladdercabletransx[1]
bf210566 1287 * TanD(fgkSSDFlexAngle),
44285dfa 1288 ssdladdercabletransx[2]
bf210566 1289 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1290 TGeoRotation* localladdercablerot[3];
bf210566 1291 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1292 localladdercablerot[0]->SetAngles(90.,0.,0.);
1293 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1294 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1295 * (*localladdercablerot[0]));
cd2243fb 1296 //TGeoRotation* localladdercablerot = new TGeoRotation();
1297 //localladdercablerot->SetAngles(90.,0.,0.);
44285dfa 1298 ////////////////////////////////////////////
1299 // LocalLadderCableCombiTransMatrix
1300 ////////////////////////////////////////////
1301 const Int_t klocalladdersidecablesnumber = 2;
1302 const Int_t klocalladdercombitransnumber = 5;
1303 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1304 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1305 localladdercablecombitransmatrix[i] =
1306 new TGeoCombiTrans*[klocalladdercombitransnumber];
1307 ///////////////////////////////////////////
1308 // Left Side Ladder Cables Transformations
1309 ///////////////////////////////////////////
1310 localladdercablecombitransmatrix[0][0] =
d7599219 1311 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1312 0.,0.,NULL);
bf210566 1313 localladdercablecombitransmatrix[0][1] =
1314 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1315 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1316 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1317 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1318 - 0.5*(fgkCarbonFiberLowerSupportWidth
1319 + fgkSSDSensorCenterSupportLength
1320 - fgkSSDSensorCenterSupportThickness[0]),
1321 - (fgkSSDModuleCoolingBlockToSensor
1322 + 0.5*fgkCoolingTubeSupportHeight
1323 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1324 - fgkSSDChipHeight),NULL);
44285dfa 1325 localladdercablecombitransmatrix[0][2] =
d7599219 1326 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1327 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1328 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1329 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1330 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1331 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1332 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1333 new TGeoRotation("",180.,0.,0.));
44285dfa 1334 localladdercablecombitransmatrix[0][4] =
1335 new TGeoCombiTrans(-ssdladdercabletransx[0]
1336 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1337 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1338 0.,
1339 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1340 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1341 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1342 + ssdladdercabletransz[2],localladdercablerot[2]);
1343 ///////////////////////////////////////////
1344 // Rigth Side Ladder Cables Transformations
1345 ///////////////////////////////////////////
bf210566 1346 TGeoCombiTrans* localladdercablessdmodulematrix =
1347 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1348 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1349 fgkSSDStiffenerWidth,
1350 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1351 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1352 localladdercablecombitransmatrix[1][i] =
bf210566 1353 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1354 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1355 ///////////////////////////////////////////
bf210566 1356 // Setting LadderCableHMatrix
44285dfa 1357 ///////////////////////////////////////////
bf210566 1358 Int_t beamaxistrans[2][3];
1359 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1360 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1361 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1362 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1363 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1364 beamaxistrans[1][2] = beamaxistrans[1][0];
1365 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1366 TGeoRotation* laddercablerot = new TGeoRotation();
1367 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1368 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1369 Double_t* laddercabletransvector;
1370 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1371 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1372 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1373 }
1374 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1375 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1376 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1377 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1378 localladdercablehmatrix[i][j]->MultiplyLeft(
1379 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1380 }
1381 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1382 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1383 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1384 laddercabletransvector[1]
bf210566 1385 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1386 * fgkCarbonFiberJunctionWidth,
bf210566 1387 laddercabletransvector[2]);
1388 laddercablecombitrans->SetRotation(*laddercablerot);
1389 laddercablecombitrans->SetTranslation(*laddercabletrans);
1390 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1391 }
1392 fladdercablematrix[i][2] =
1393 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1394 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1395 fladdercablematrix[i][3] =
1396 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1397 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1398 }
1399 for(Int_t i=0; i<fgkladdercablesnumber; i++)
78e34526 1400 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1401 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1402
bf210566 1403 ///////////////////////////////////////////
1404 // Setting Ladder HMatrix
1405 ///////////////////////////////////////////
1406 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1407 fgkSSDLay6SensorsNumber};
1408 for(Int_t i=0; i<fgkladdernumber; i++){
1409 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1410 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1411 fladdermatrix[i][j] = new TGeoHMatrix();
1412 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1413 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1414 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1415 }
1416 }
1417 ///////////////////////////////////////////
1418 // Setting SSD Sensor Matrix
1419 ///////////////////////////////////////////
1420 TGeoCombiTrans* localssdsensorcombitrans[2];
1421 TGeoRotation* localssdsensorrot = new TGeoRotation();
1422 localssdsensorrot->SetAngles(0.,90.,0.);
1423 TGeoTranslation* localssdsensortrans[2];
1424 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1425 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1426 fgkCarbonFiberJunctionWidth
1427 - fgkCarbonFiberLowerSupportWidth
1428 - fgkLowerSupportToSensorZ,
bf210566 1429 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1430 - fgkSSDModuleCoolingBlockToSensor
e21cdd03 1431 + (fgkSSDSensorSideSupportHeight[1]
0fb26117 1432 - fgkSSDSensorSideSupportHeight[0]));
bf210566 1433 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1434 fgkCarbonFiberJunctionWidth
1435 - fgkCarbonFiberLowerSupportWidth
1436 - fgkLowerSupportToSensorZ,
bf210566 1437 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1438 -fgkSSDModuleCoolingBlockToSensor);
cd2243fb 1439
bf210566 1440 for(Int_t i=0; i<2; i++)
1441 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1442 *localssdsensorrot);
1443 for(Int_t i=0; i<fgkladdernumber; i++){
1444 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1445 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1446 switch(i){
1447 case 0: //Ladder of Layer5
1448 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1449 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1450 *localssdsensorcombitrans[1])));
1451 break;
1452 case 1: //Ladder of Layer6
1453 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1454 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1455 *localssdsensorcombitrans[0])));
1456 break;
1457 }
1458 }
1459 }
1460 //////////////////////////
1461 // Setting SSD End Ladder
1462 //////////////////////////
1463 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1464 for(Int_t i=0; i<2; i++){
1465 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1466 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1467 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1468 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1469 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1470 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1471 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1472 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1473 }
1474 /////////////////////////////////////////////////////
1475 // Setting the CombiTransformation to pass ITS center
1476 /////////////////////////////////////////////////////
1477 Double_t itscentertransz[fgklayernumber];
1478 itscentertransz[0] = fgkSSDLay5LadderLength
1479 - fgkLay5CenterITSPosition;
1480 itscentertransz[1] = fgkSSDLay6LadderLength
1481 - fgkLay6CenterITSPosition;
1482 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1483 + 0.5*fgkCoolingTubeSupportHeight;
1484 TGeoRotation* itscenterrot[3];
1485 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1486 itscenterrot[0]->SetAngles(90.,180.,-90.);
1487 itscenterrot[1]->SetAngles(0.,90.,0.);
1488 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1489 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1490 for(Int_t i=0; i<fgklayernumber; i++)
1491 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1492 itssensortransy,
1493 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1494 - itscentertransz[i],itscenterrot[2]);
1495 TGeoRotation** locallayerrot[fgklayernumber];
1496 TGeoTranslation** locallayertrans[fgklayernumber];
1497 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1498 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1499 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1500 - fgkLay5CenterITSPosition);
1501 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1502 - fgkLay6CenterITSPosition);
1503 const Int_t kssdlayladdernumber[fgklayernumber] =
1504 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1505 for(Int_t i=0; i<fgklayernumber; i++){
1506 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1507 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1508 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1509 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1510 }
1511 Double_t layerladderangleposition[fgklayernumber] =
1512 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1513 Double_t layerradius = 0.;
1514 for(Int_t i=0; i<fgklayernumber; i++){
1515 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1516 switch(i){
1517 case 0: //Ladder of Layer5
1518 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1519 break;
1520 case 1: //Ladder of Layer6
1521 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1522 break;
1523 }
1524 locallayerrot[i][j] = new TGeoRotation();
1525 locallayertrans[i][j] = new TGeoTranslation();
1526 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1527 locallayertrans[i][j]->SetTranslation(layerradius
1528 * CosD(90.0+j*layerladderangleposition[i]),
1529 layerradius
1530 * SinD(90.0+j*layerladderangleposition[i]),0.);
1531 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1532 *locallayerrot[i][j]);
1533 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1534 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1535 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1536 }
1537 }
44285dfa 1538 /////////////////////////////////////////////////////////////
bf210566 1539 // Deallocating memory
44285dfa 1540 /////////////////////////////////////////////////////////////
bf210566 1541 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1542 delete carbonfiberot[i];
1543 delete localcarbonfibersupportmatrix[i];
1544 }
1545 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1546 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1547 delete localcarbonfiberjunctionmatrix[i][j];
1548 delete localcarbonfiberjunctionrot[i][j];
1549 delete localcarbonfiberjunctiontrans[i][j];
1550 }
1551 delete [] localcarbonfiberjunctionmatrix[i];
1552 delete [] localcarbonfiberjunctionrot[i];
1553 delete [] localcarbonfiberjunctiontrans[i];
1554 }
1555 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1556 delete localcarbonfiberlowersupportrans[i];
1557 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1558 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1559 delete localssdsensorsupportmatrix[i][j];
1560 delete localssdsensorsupportrot[i][j];
1561 delete localssdsensorsupportrans[i][j];
1562 }
1563 delete [] localssdsensorsupportmatrix[i];
1564 delete [] localssdsensorsupportrot[i];
1565 delete [] localssdsensorsupportrans[i];
1566 }
1567 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1568 delete localcoolingtubesupportmatrix[i];
1569 delete localcoolingtubesupportrot[i];
1570 delete localcoolingtubesupportrans[i];
1571 }
cd2243fb 1572 for(Int_t j=0; j<2; j++){
1573 delete localcoolingtubevect[j];
1574 delete localcoolingtubetrans[j];
bf210566 1575 }
9b0c60ab 1576 delete endladdermountingblockrot;
bf210566 1577 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
bf210566 1578 for(Int_t i=0; i<fgkflexnumber; i++){
1579 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1580 delete localflexmatrix[i][j];
1581 delete [] localflexmatrix[i];
1582 }
9b0c60ab 1583 delete localendlladdercoolingtuberot;
1584 for(Int_t i=0; i<2; i++){
cd2243fb 1585 for(Int_t j=0; j<2; j++)
1586 delete localendlladdercoolingtubetrans[i][j];
9b0c60ab 1587 delete [] localendlladdercoolingtubetrans[i];
1588 }
1589
bf210566 1590 delete localflexrot;
1591 delete localendflexrot;
1592 delete localendflexmatrix;
1593 for(Int_t i=0; i<fgkladdernumber; i++){
1594 delete localladdermothertrans[i];
1595 delete localladdermothercombitrans[i];
1596 }
1597 delete localladdermotherrot;
1598 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
b28b5356 1599 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
bf210566 1600 delete localendladdercarbonfiberjunctionmatrix[i][j];
1601 delete localendladdercarbonfiberjunctionrot[i][j];
1602 delete localendladdercarbonfiberjunctiontrans[i][j];
1603 }
1604 delete [] localendladdercarbonfiberjunctionmatrix[i];
1605 delete [] localendladdercarbonfiberjunctionrot[i];
1606 delete [] localendladdercarbonfiberjunctiontrans[i];
1607 delete localendladdercarbonfiberjunctionglobalrot[i];
1608 delete localendladdercarbonfiberjunctionglobaltrans[i];
1609 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1610 }
9b0c60ab 1611 for(Int_t i=0; i<2; i++){
1612 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1613 delete [] localendladdercooltubetrans[i];
1614 }
1615 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1616 delete localendladdercarbonfibertrans[i];
1617 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1618 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1619 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1620 delete localladdercablecombitransmatrix[i][j];
1621 delete []localladdercablecombitransmatrix[i];
1622 }
9b0c60ab 1623 delete localendladdercliprot;
1624 delete localendladdercliptrans;
bf210566 1625 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1626 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1627 delete localladdercablehmatrix[i][j];
1628 delete []localladdercablehmatrix[i];
1629 }
1630 delete laddercablerot;
1631 delete laddercabletrans;
1632 delete laddercablecombitrans;
1633 delete localladdercablessdmodulematrix;
1634 delete localssdsensorrot;
1635 for(Int_t i=0; i<2; i++){
1636 delete localssdsensortrans[i];
1637 delete localssdsensorcombitrans[i];
1638 }
1639 for(Int_t i=0; i<fgklayernumber; i++){
1640 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1641 delete locallayerrot[i][j];
1642 delete locallayertrans[i][j];
1643 delete locallayercombitrans[i][j];
1644 }
1645 delete [] locallayerrot[i];
1646 delete [] locallayertrans[i];
1647 delete [] locallayercombitrans[i];
1648 delete localbeamaxistrans[i];
1649 }
1650 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1651 for(Int_t i=0; i<fgkladdernumber; i++){
1652 for(Int_t j=0; j<fgkladdernumber; j++)
1653 delete ladderglobalmatrix[i][j];
1654 delete [] ladderglobalmatrix[i];
1655 }
1656 /////////////////////////////////////////////////////////////
1657 fTransformationMatrices = kTRUE;
d7599219 1658}
bf210566 1659///////////////////////////////////////////////////////////////////////////////
1660void AliITSv11GeometrySSD::CreateBasicObjects(){
1661 /////////////////////////////////////////////////////////////
1662 // Method generating the Objects of SSD Geometry
1663 /////////////////////////////////////////////////////////////
1664 // SSD Sensor
1665 ///////////////////////////////////
1666 SetSSDSensor();
1667 /////////////////////////////////////////////////////////////
1668 // Carbon Fiber Support
1669 /////////////////////////////////////////////////////////////
1670 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1671 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1672 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1673 /////////////////////////////////////////////////////////////
bf210566 1674 // Carbon Fiber Junction
44285dfa 1675 /////////////////////////////////////////////////////////////
ca86fdb4 1676 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
bf210566 1677 /////////////////////////////////////////////////////////////
1678 // Carbon Fiber Lower Support
1679 /////////////////////////////////////////////////////////////
1680 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1681 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1682 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1683 /////////////////////////////
1684 // SSD Sensor Support
1685 /////////////////////////////
1686 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1687 new TGeoVolume*[fgkssdsensorsupportnumber];
44285dfa 1688 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
bf210566 1689 fgkSSDSensorSideSupportThickness[1]};
1690 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1691 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1692 fgkSSDSensorSideSupportHeight[i],
1693 fgkSSDSensorSideSupportWidth,
1694 sidesupporthickness);
1695 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1696 fgkSSDSensorCenterSupportHeight[i],
1697 fgkSSDSensorCenterSupportWidth,
1698 sidesupporthickness);
1699 }
1700 /////////////////////////////////////////////////////////////
1701 // SSD Cooling Tube Support
1702 /////////////////////////////////////////////////////////////
3c057f23 1703 Int_t edgesnumber = 3;
bf210566 1704 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1705 /////////////////////////////////////////////////////////////
1706 // SSD Hybrid
1707 /////////////////////////////////////////////////////////////
1708 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1709 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1710 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1711 /////////////////////////////////////////////////////////////
1712 // SSD Cooling Block System
1713 /////////////////////////////////////////////////////////////
1714 fssdcoolingblocksystem = GetCoolingBlockSystem();
1715 /////////////////////////////////////////////////////////////
1716 // SSD Cooling Tube
1717 /////////////////////////////////////////////////////////////
cd2243fb 1718 CreateCoolingTubes();
bf210566 1719 /////////////////////////////////////////////////////////////
1720 // SSD Flex
1721 /////////////////////////////////////////////////////////////
1722 fssdstiffenerflex = GetSSDStiffenerFlex();
1723 fssdendflex = GetSSDEndFlex();
1724 ///////////////////////////////////
1725 // End Ladder Carbon Fiber Junction
1726 ///////////////////////////////////
1727 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1728 fendladdercarbonfiberjunction[i] =
1729 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1730 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1731 fendladdercarbonfiberjunction[i][0] =
ca86fdb4 1732 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
bf210566 1733 fendladdercarbonfiberjunction[i][1] =
ca86fdb4 1734 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
bf210566 1735 }
1736 ///////////////////////////////////
1737 // End Ladder Mounting Block
1738 ///////////////////////////////////
1739 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1740 ///////////////////////////////////
1741 // End Ladder Mounting Block
1742 ///////////////////////////////////
1743 fendladdermountingblockclip = GetMountingBlockClip();
1744 ///////////////////////////////////
1745 // Ladder Support
1746 ///////////////////////////////////
1747 TList* laddersupportlist = GetMountingBlockSupport(20);
1748 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1749 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1750 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1751 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
bf210566 1752 /////////////////////////////////////////////////////////////
1753 // Deallocating memory
44285dfa 1754 /////////////////////////////////////////////////////////////
bf210566 1755 delete carbonfibersupportlist;
1756 delete carbonfiberlowersupportlist;
1757 delete ssdhybridcomponentslist;
9b0c60ab 1758 delete laddersupportlist;
44285dfa 1759 /////////////////////////////////////////////////////////////
bf210566 1760 fBasicObjects = kTRUE;
1761}
1762/////////////////////////////////////////////////////////////////////////////////
1763void AliITSv11GeometrySSD::SetSSDSensor(){
1764 ////////////////////////////////////////////////////////////////
1765 // Method generating SSD Sensors: it sets the private variables
1766 // fSSDSensor5, fSSDSensor6
1767 ////////////////////////////////////////////////////////////////
44285dfa 1768 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1769 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1770 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
44285dfa 1771 0.5*ssdsensitivewidth,
bf210566 1772 0.5*fgkSSDSensorHeight,
1773 0.5*ssdsensitivelength);
1774 TGeoVolume* ssdsensorsensitiveLay5 =
f510fd70 1775 new TGeoVolume(fgkSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1776 TGeoVolume* ssdsensorsensitiveLay6 =
f510fd70 1777 new TGeoVolume(fgkSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1778 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1779 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
44285dfa 1780 TGeoBBox* ssdsensorinsensitiveshape[2];
1781 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1782 0.5*fgkSSDSensorInsensitiveWidth,
bf210566 1783 0.5*fgkSSDSensorHeight,
1784 0.5*fgkSSDSensorLength);
44285dfa 1785 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
44285dfa 1786 0.5*ssdsensitivewidth,
bf210566 1787 0.5*fgkSSDSensorHeight,
1788 0.5*fgkSSDSensorInsensitiveWidth);
44285dfa 1789 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1790 "SSDSensorInsensitive2"};
44285dfa 1791 TGeoVolume* ssdsensorinsensitive[2];
1792 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1793 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1794 fSSDSensorMedium);
1795 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1796 }
bf210566 1797 /////////////////////////////////////////////////////////////
1798 // Virtual Volume containing SSD Sensor
1799 /////////////////////////////////////////////////////////////
1800 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1801 0.5*fgkSSDSensorWidth,
1802 0.5*fgkSSDSensorHeight,
1803 0.5*fgkSSDSensorLength);
ef9451a3 1804 fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
bf210566 1805 fSSDAir);
ef9451a3 1806 fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
bf210566 1807 fSSDAir);
1808 /////////////////////////////////////////////////////////////
1809 for(Int_t i=0; i<4; i++){
1810 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1811 ssdsensorinsensitive[1],i<2?1:2,
1812 new TGeoTranslation(
1813 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1814 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1815 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1816 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1817 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
44285dfa 1818 ssdsensorinsensitive[1],i<2?1:2,
bf210566 1819 new TGeoTranslation(
1820 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1821 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1822 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1823 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1824 }
1825 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1826 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1827}
bf210566 1828///////////////////////////////////////////////////////////////////////////////
1829TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1830 /////////////////////////////////////////////////////////////
1831 // Method generating the Carbon Fiber Support
1832 /////////////////////////////////////////////////////////////
1833 const Int_t kvertexnumber = 4;
1834 const Int_t kshapesnumber = 2;
1835 TVector3** vertexposition[kshapesnumber];
1836 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1837 Double_t carbonfibersupportxaxisEdgeproj =
1838 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1839 * TMath::DegToRad());
1840 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1841 / fgkCarbonFiberSupportXAxisLength);
1842 /////////////////////
1843 //Vertex Positioning
1844 ////////////////////
1845 vertexposition[0][0] = new TVector3();
1846 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
c2aad3ae 1847 fgkCarbonFiberSupportYAxisLength, 0);
bf210566 1848 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1849 carbonfibersupportxaxisEdgeproj
c2aad3ae 1850 * TMath::Tan(theta), 0);
bf210566 1851 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1852 - carbonfibersupportxaxisEdgeproj,
1853 fgkCarbonFiberSupportYAxisLength
c2aad3ae 1854 - vertexposition[0][2]->Y(), 0);
bf210566 1855 ////////////////////////////////////////////////////
1856 //Setting the parameters for Isometry Transformation
1857 ////////////////////////////////////////////////////
1858 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1859 + fgkCarbonFiberSupportTopEdgeDist[0]
1860 + fgkCarbonFiberSupportWidth);
1861 Double_t* param = new Double_t[4];
1862 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1863 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
160835d5 1864 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
c2aad3ae 1865 (GetReflection(vertexposition[0][j],param))->Y(), 0);
a6e0ebfe 1866 const char* carbonfibersupportshapename[kshapesnumber] =
bf210566 1867 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
a6e0ebfe 1868 const char* carbonfibersupportname[kshapesnumber] =
bf210566 1869 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1870 TGeoArb8* carbonfibersupportshape[kshapesnumber];
1871 TGeoVolume* carbonfibersupport[kshapesnumber];
1872 TList* carbonfibersupportlist = new TList();
1873 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1874 Double_t carbonfibersupportheight =
1875 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1876 *TMath::DegToRad());
1877 for(Int_t i = 0; i< kshapesnumber; i++){
1878 carbonfibersupportshape[i] =
1879 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1880 carbonfibersupportshapename[i],i==0 ? 1: -1);
1881 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1882 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1883 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1884 carbonfibersupportlist->Add(carbonfibersupport[i]);
1885 }
1886 /////////////////////////////////////////////////////////////
1887 // Deallocating memory
1888 /////////////////////////////////////////////////////////////
1889 for(Int_t i=0; i< kshapesnumber; i++){
1890 for(Int_t j=0; j< kvertexnumber; j++)
1891 delete vertexposition[i][j];
1892 delete [] vertexposition[i];
1893 }
1894 delete [] param;
44285dfa 1895 /////////////////////////////////////////////////////////////
bf210566 1896 return carbonfibersupportlist;
d7599219 1897}
1898/////////////////////////////////////////////////////////////////////////////////
bf210566 1899TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 1900 /////////////////////////////////////////////////////////////
bf210566 1901 // Method generating SSD Carbon Fiber Junction
44285dfa 1902 /////////////////////////////////////////////////////////////
bf210566 1903 const Int_t kvertexnumber = 6;
1904 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
d4ff3e0a 1905 Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1906 * TMath::DegToRad()),-1.,0.,0.};
bf210566 1907 TVector3* vertex[kvertexnumber];
1908 vertex[0] = new TVector3();
1909 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
1910 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1911 * TMath::DegToRad()),
1912 fgkCarbonFiberJunctionEdge[0]
1913 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
c2aad3ae 1914 * TMath::DegToRad()), 0);
5d9d4033 1915 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance,
c2aad3ae 1916 fgkCarbonFiberJunctionEdge[1], 0);
1917 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance, 0, 0);
bf210566 1918 vertex[1] = GetReflection(vertex[5],reflectionparam);
1919 vertex[2] = GetReflection(vertex[4],reflectionparam);
1920 Double_t xvertexpoints[6], yvertexpoints[6];
1921 for(Int_t i=0; i<kvertexnumber; i++)
1922 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
1923 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
1924 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
1925 carbonfiberjunctionshape->DefineSection(1,0.5*width);
1926 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
1927 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
1928 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
1929 /////////////////////////////////////////////////////////////
1930 // Deallocating memory
1931 /////////////////////////////////////////////////////////////
1932 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
1933 /////////////////////////////////////////////////////////////
1934 return carbonfiberjunction;
1935}
1936////////////////////////////////////////////////////////////////////////////////
1937TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
1938 /////////////////////////////////////////////////////////////
1939 // Method generating the Carbon Fiber Lower Support
1940 /////////////////////////////////////////////////////////////
1941 const Int_t kvertexnumber = 4;
1942 const Int_t kshapesnumber = 2;
1943 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
1944 fgkCarbonFiberLowerSupportWidth};
1945 TVector3** vertexposition[kshapesnumber];
1946 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
1947 new TVector3*[kvertexnumber];
1948 //First Shape Vertex Positioning
c2aad3ae 1949 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght, 0, 0);
bf210566 1950 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
c2aad3ae 1951 - fgkCarbonFiberLowerSupportLowerLenght, 0, 0);
bf210566 1952 vertexposition[0][2] = new TVector3();
c2aad3ae 1953 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength, 0, 0);
bf210566 1954 //Second Shape Vertex Positioning
1955 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
1956 - fgkCarbonFiberLowerSupportVolumePosition[0])
1957 / fgkCarbonFiberTriangleLength);
1958 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
1959 vertexposition[0][0]->X()*TMath::Tan(theta)
c2aad3ae 1960 + fgkCarbonFiberLowerSupportVolumePosition[0], 0);
bf210566 1961 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
1962 vertexposition[0][1]->X()*TMath::Tan(theta)
c2aad3ae 1963 + fgkCarbonFiberLowerSupportVolumePosition[0], 0);
1964 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0], 0);
bf210566 1965 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
c2aad3ae 1966 fgkCarbonFiberLowerSupportVolumePosition[1], 0);
a6e0ebfe 1967 const char* carbonfiberlowersupportshapename[kshapesnumber] =
bf210566 1968 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
a6e0ebfe 1969 const char* carbonfiberlowersupportname[kshapesnumber] =
bf210566 1970 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
1971 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
1972 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
1973 TList* carbonfiberlowersupportlist = new TList();
1974 for(Int_t i = 0; i< kshapesnumber; i++){
1975 carbonfiberlowersupportshape[i] =
1976 GetArbShape(vertexposition[i],width,
1977 fgkCarbonFiberLowerSupportHeight,
1978 carbonfiberlowersupportshapename[i]);
1979 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
1980 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
1981 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
1982 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
1983 }
1984 /////////////////////////////////////////////////////////////
1985 // Deallocating memory
1986 /////////////////////////////////////////////////////////////
1987 for(Int_t i=0; i< kshapesnumber; i++){
1988 for(Int_t j=0; j< kvertexnumber; j++)
1989 delete vertexposition[i][j];
1990 delete [] vertexposition[i];
1991 }
1992 /////////////////////////////////////////////////////////////
1993 return carbonfiberlowersupportlist;
1994}
1995///////////////////////////////////////////////////////////////////////////////
1996TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
5cb5bc3d 1997 Double_t width, const Double_t* thickness)const{
bf210566 1998 /////////////////////////////////////////////////////////////
1999 // Method generating the Sensor Support
2000 /////////////////////////////////////////////////////////////
2001 const Int_t kvertexnumber = 6;
2002 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2003 TVector3* vertexposition[kvertexnumber];
2004 vertexposition[0] = new TVector3();
c2aad3ae 2005 vertexposition[1] = new TVector3(0.0,length,0);
2006 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y(),0);
2007 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0],0);
2008 vertexposition[4] = new TVector3(height,vertexposition[3]->Y(),0);
2009 vertexposition[5] = new TVector3(vertexposition[4]->X(),0,0);
bf210566 2010 Double_t xvertexpoints[6], yvertexpoints[6];
2011 for(Int_t i=0; i<kvertexnumber; i++)
2012 xvertexpoints[i] = vertexposition[i]->X(),
2013 yvertexpoints[i] = vertexposition[i]->Y();
2014 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2015 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2016 ssdsensorsupportshape->DefineSection(1,0.5*width);
2017 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2018 ssdsensorsupportshape,fSSDSensorSupportMedium);
2019 /////////////////////////////////////////////////////////////
2020 // Deallocating memory
2021 /////////////////////////////////////////////////////////////
2022 for (Int_t i=0; i<kvertexnumber; i++)
2023 delete vertexposition[i];
2024 /////////////////////////////////////////////////////////////
2025 return ssdsensorsupport;
2026}
2027////////////////////////////////////////////////////////////////////////////////
2028TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2029 /////////////////////////////////////////////////////////////
2030 // Method generating the Cooling Tube Support
2031 /////////////////////////////////////////////////////////////
2032 if(nedges%2!=0) nedges--;
2033 const Int_t kvertexnumber = nedges+5;
2034 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2035 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2036 Double_t angle = 90.+phi;
2037 Double_t psi = 90.-phi;
2038 ///////////////////////////////////////
2039 // Vertex Positioning for TGeoXTru
2040 ///////////////////////////////////////
2041 TVector3** vertexposition = new TVector3*[kvertexnumber];
cd2243fb 2042
f510fd70 2043 Double_t router = fgkCoolingTubeSupportRmin/CosD(phi/nedges); // Recalc inner radius so that tube fits inside
2044 vertexposition[0] = new TVector3(router*CosD(angle),
c2aad3ae 2045 router*SinD(angle), 0);
bf210566 2046 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
c2aad3ae 2047 fgkCoolingTubeSupportRmax*SinD(angle),0);
bf210566 2048 vertexposition[2] = new TVector3(vertexposition[1]->X(),
c2aad3ae 2049 fgkCoolingTubeSupportRmax, 0);
bf210566 2050 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
c2aad3ae 2051 fgkCoolingTubeSupportRmax, 0);
bf210566 2052 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
c2aad3ae 2053 vertexposition[1]->Y(), 0);
cd2243fb 2054
bf210566 2055 for(Int_t i=0; i<nedges; i++)
2056 vertexposition[i+5] =
f510fd70 2057 new TVector3(router*CosD(psi+i*(2.*phi/nedges)),
c2aad3ae 2058 router*SinD(psi+i*(2.*phi/nedges)), 0);
bf210566 2059 ///////////////////////////////////////////////////////////////////////
2060 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2061 ///////////////////////////////////////////////////////////////////////
2062 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2063 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2064 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2065 for(Int_t i=0; i<kvertexnumber; i++){
2066 xvertexpoints[i] = vertexposition[i]->X();
2067 yvertexpoints[i] = vertexposition[i]->Y();
2068 }
2069 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2070 yvertexpoints);
2071 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2072 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2073 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2074 coolingtubesupportarcshape,
2075 fSSDTubeHolderMedium);
2076 coolingtubesupportarc->SetLineColor(fColorG10);
2077 //////////////////////////////////////////////////////////////////////////
2078 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2079 //////////////////////////////////////////////////////////////////////////
2080 TGeoTubeSeg* coolingtubesupportsegshape =
2081 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2082 fgkCoolingTubeSupportRmax,
2083 0.5*fgkCoolingTubeSupportWidth,
2084 phi,360-phi);
2085 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2086 coolingtubesupportsegshape,
2087 fSSDTubeHolderMedium);
2088 coolingtubesupportseg->SetLineColor(fColorG10);
2089 //////////////////////////////////////////////////////////////////////////
2090 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2091 //////////////////////////////////////////////////////////////////////////
2092 Double_t* boxorigin = new Double_t[3];
2093 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2094 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2095 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2096 0.5*fgkCoolingTubeSupportHeight,
2097 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2098 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2099 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2100 coolingtubesupportbox->SetLineColor(fColorG10);
2101 //////////////////////////////////////////////////////////////////////////
2102 // Cooling Tube for Cooling Tube Support
2103 //////////////////////////////////////////////////////////////////////////
2104 TGeoXtru* coolingtubearcshape[2];
2105 coolingtubearcshape[0] = new TGeoXtru(2);
2106 Double_t* xvert = new Double_t[nedges+2];
2107 Double_t* yvert = new Double_t[nedges+2];
2108 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2109 ////////////////////////////////////////
2110 // Positioning the vertices for TGeoXTru
2111 ////////////////////////////////////////
2112 xvert[0] = 0., yvert[0] = 0.;
2113 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2114 for(Int_t i=0; i< nedges; i++)
2115 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2116 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2117 ////////////////////////////////////////
2118 // Defining TGeoXTru PolyGone
2119 ////////////////////////////////////////
2120 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2121 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2122 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2123 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2124 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2125 TGeoVolume* coolingtubearc[2];
2126 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2127 coolingtubearcshape[0],fSSDCoolingTubeWater);
2128 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2129 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2130 coolingtubearc[0]->SetLineColor(fColorWater);
2131 coolingtubearc[1]->SetLineColor(fColorPhynox);
2132 ////////////////////////////////////////////
2133 // Defining TGeoTubeSeg Part of Cooling Tube
2134 ////////////////////////////////////////////
2135 TGeoTubeSeg* coolingtubesegshape[2];
2136 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2137 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2138 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2139 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2140 TGeoVolume* coolingtubeseg[2];
2141 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2142 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2143 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2144 coolingtubesegshape[1],fSSDCoolingTubeWater);
2145 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2146 coolingtubeseg[1]->SetLineColor(fColorWater);
2147 /////////////////////////////////////////////////////////////
2148 // Virtual Volume containing Cooling Tube Support
2149 /////////////////////////////////////////////////////////////
2150 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2151 const Int_t kvirtualvertexnumber = 8;
2152 TVector3* virtualvertex[kvirtualvertexnumber];
2153 ////////////////////////////////////////
2154 // Positioning the vertices for TGeoXTru
2155 ////////////////////////////////////////
c2aad3ae 2156 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax, 0);
2157 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y(),0);
2158 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y(),0);
2159 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight,0);
2160 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y(),0);
2161 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y(),0);
2162 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y(),0);
2163 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y(),0);
bf210566 2164 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2165 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2166 xmothervertex[i] = virtualvertex[i]->X(),
2167 ymothervertex[i] = virtualvertex[i]->Y();
2168 ////////////////////////////////////////
2169 // Defining TGeoXTru PolyGone
2170 ////////////////////////////////////////
2171 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2172 ymothervertex);
2173 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2174 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
cd2243fb 2175 /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2176 virtualCoolingTubeSupportShape,fSSDAir); */
2177 TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
2178
bf210566 2179 ////////////////////////////////////////
2180 // Positioning Volumes in Virtual Volume
2181 ////////////////////////////////////////
2182 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2183 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2184 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2185 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2186 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
cd2243fb 2187 //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2188 //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2189 //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2190 //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
bf210566 2191 /////////////////////////////////////////////////////////////
2192 // Deallocating memory
2193 /////////////////////////////////////////////////////////////
2194 delete [] vertexposition;
3e008bd7 2195 delete [] xvertexpoints;
2196 delete [] yvertexpoints;
2197 delete [] xvert;
2198 delete [] yvert;
bf210566 2199 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2200 delete virtualvertex[i];
2201 /////////////////////////////////////////////////////////////
2202 return virtualcoolingtubesupport;
2203}
2204/////////////////////////////////////////////////////////////////////////////////
2205TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2206 /////////////////////////////////////////////////////////////
2207 // Method generating List containing SSD Hybrid Components
2208 /////////////////////////////////////////////////////////////
2209 TList* ssdhybridlist = new TList();
2210 const Int_t kssdstiffenernumber = 2;
2211 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2212 - 2.*fgkSSDModuleStiffenerPosition[1]
2213 - fgkSSDStiffenerWidth;
2214 Double_t ssdchipcablesradius[kssdstiffenernumber];
2215 for(Int_t i=0; i<kssdstiffenernumber; i++)
2216 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2217 - fgkSSDChipCablesHeight[0]
2218 - fgkSSDChipCablesHeight[1]);
2219 /////////////////////////////////////////////////////////////
2220 // Mother Volumes Containers
2221 /////////////////////////////////////////////////////////////
2222 const Int_t kmothernumber = 2;
3cf6a656 2223 const Int_t kmothervertexnumber = 8;
bf210566 2224 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2225 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
3cf6a656 2226
2227 TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
2228 TGeoVolume* ssdhybridmother[kmothernumber][2];
2229
2230 TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
2231 TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
2232 TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
2233
bf210566 2234 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2235 for(Int_t i=0; i<kmothernumber; i++){
3cf6a656 2236 xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
2237 ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
2238 xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
2239 ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2240 -fgkSSDChipCablesHeight[i+2];
2241
2242 xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
2243 ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
2244 xmothervertex[i][3] = xmothervertex[i][2];
5d9d4033 2245 ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1]+fgkSSDTolerance;
3cf6a656 2246
2247 xmothervertex[i][4] = xmothervertex[i][2]-0.4;
2248 ymothervertex[i][4] = ymothervertex[i][3];
2249 xmothervertex[i][5] = xmothervertex[i][4];
5d9d4033 2250 ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i]-fgkSSDTolerance;
3cf6a656 2251
2252 xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
2253 ymothervertex[i][6] = ymothervertex[i][5];
2254
2255 xmothervertex[i][7] = xmothervertex[i][6];
2256 ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
3cf6a656 2257 TGeoXtru *shape = new TGeoXtru(2);
2258 shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
2259 shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
2260 shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
2261 ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
2262 ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
2263 ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
bf210566 2264 }
2265 /////////////////////////////////////////////////////////////
2266 // SSD Stiffener
2267 /////////////////////////////////////////////////////////////
2268 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2269 0.5*fgkSSDStiffenerLength,
ca86fdb4 2270 0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
bf210566 2271 0.5*fgkSSDStiffenerHeight);
2272 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2273 fSSDStiffenerMedium);
2274 ssdstiffener->SetLineColor(fColorStiffener);
3cf6a656 2275
bf210566 2276////////////////////////////
2277// Capacitor 0603-2200 nF
2278///////////////////////////
2279 const Int_t knapacitor0603number = 5;
78e34526 2280 TGeoBBox* capacitor0603mothershape = new TGeoBBox("Capacitor0603MotherShape",
2281 0.5*fgkSSDCapacitor0603Length + fgkSSDCapacitor0603CapLength,
2282 0.5*fgkSSDCapacitor0603Width,
2283 0.5*fgkSSDCapacitor0603Height);
2284 TGeoVolume* capacitor0603mother = new TGeoVolume("Capacitor0603Mother",capacitor0603mothershape,
2285 fSSDAir);
2286
bf210566 2287 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
3cf6a656 2288 0.5*fgkSSDCapacitor0603Length,
78e34526 2289 0.5*fgkSSDCapacitor0603Width,
3cf6a656 2290 0.5*fgkSSDCapacitor0603Height);
bf210566 2291 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2292 fSSDStiffener0603CapacitorMedium);
2293 capacitor0603->SetLineColor(fColorAl);
78e34526 2294 TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.);
2295 capacitor0603mother->AddNode(capacitor0603,1,cap0603trans);
2296
2297 TGeoBBox* capacitor0603capshape = new TGeoBBox("Capacitor0603CapShape",
2298 0.5*fgkSSDCapacitor0603CapLength,
2299 0.5*fgkSSDCapacitor0603Width,
2300 0.5*fgkSSDCapacitor0603Height);
2301 TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape,
2302 fSSDStiffenerCapacitorCapMedium);
2303 capacitor0603cap->SetLineColor(fColorNiSn);
2304 TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.);
2305 capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1);
2306 TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.);
2307 capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2);
2308
3cf6a656 2309
2310 TGeoVolume* ssdchip = GetSSDChip();
2311
2312 const Int_t knedges = 5;
2313 TGeoVolume *ssdchipcables[2];
2314
bf210566 2315 for(Int_t i=0; i<kmothernumber; i++){
3cf6a656 2316 for(Int_t j=0; j<kssdstiffenernumber; j++){
2317 ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
2318 for(Int_t k=1; k<knapacitor0603number+1; k++){
78e34526 2319 ssdhybridmother[i][j]->AddNode(capacitor0603mother,k,
3cf6a656 2320 new TGeoCombiTrans("",
2321 -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
2322 -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
2323 (k-3.)/6*fgkSSDStiffenerLength,
2324 hybridmotherrotInv));
2325 }
2326 }
2327
2328 GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
2329 for(Int_t k=0; k<fgkSSDChipNumber; k++){
2330 TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
2331 - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
2332 - fgkSSDChipCablesHeight[i+2],
2333 (k+0.5-fgkSSDChipNumber/2)*
2334 (fgkSSDChipLength + fgkSSDChipSeparationLength));
2335 TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
2336 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
2337 (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
2338 hybridmotherrotInv);
bf210566 2339 for(Int_t j=0; j<kssdstiffenernumber; j++){
3cf6a656 2340 ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
2341 ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
2342 }
2343 }
2344 // Final placement by assembly
2345 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
2346 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
2347 ssdhybridlist->Add(ssdhybridassembly[i]);
bf210566 2348 }
3cf6a656 2349 /////////////////////////////////////////////////////////////
2350 // Mother Volume Containing Capacitor Part
2351 /////////////////////////////////////////////////////////////
bf210566 2352 const Int_t kcapacitormothernumber = 8;
2353 Double_t xcapacitorvertex[kcapacitormothernumber];
2354 Double_t ycapacitorvertex[kcapacitormothernumber];
2355 ///////////////////////
2356 // Setting the vertices
2357 ///////////////////////
2358 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2359 xcapacitorvertex[1] = xcapacitorvertex[0];
2360 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2361 xcapacitorvertex[3] = xcapacitorvertex[2];
2362 xcapacitorvertex[4] = xcapacitorvertex[0];
2363 xcapacitorvertex[5] = xcapacitorvertex[0];
2364 xcapacitorvertex[6] = -xcapacitorvertex[0];
2365 xcapacitorvertex[7] = xcapacitorvertex[6];
2366 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2367 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2368 ycapacitorvertex[2] = ycapacitorvertex[1];
2369 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2370 ycapacitorvertex[4] = ycapacitorvertex[3];
2371 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2372 ycapacitorvertex[6] = ycapacitorvertex[5];
2373 ycapacitorvertex[7] = ycapacitorvertex[0];
2374 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2375 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2376 ycapacitorvertex);
2377 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2378 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
ca86fdb4 2379// TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2380// fSSDAir);
2381 TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
d7599219 2382////////////////////////////
bf210566 2383// Connector
d7599219 2384///////////////////////////
78e34526 2385 const Int_t kssdconnectorlayernumber = 3;
2386 TGeoBBox* ssdconnectorshape[kssdconnectorlayernumber];
2387 Double_t ssdConnectorThickness[kssdconnectorlayernumber]={fgkSSDConnectorAlHeight,fgkSSDConnectorNiHeight,fgkSSDConnectorSnHeight};
2388 /*
bf210566 2389 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2390 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2391 + fgkSSDConnectorAlHeight};
78e34526 2392 */
2393 Double_t ssdconnectororigin[3] = {0,0,0.5*fgkSSDStiffenerHeight};
2394 const char* ssdconnectorname[kssdconnectorlayernumber] = {"SSDConnectorAl","SSDConnectorNi","SSDConnectorSn"};
2395 TGeoMedium *ssdConnectorMedium[kssdconnectorlayernumber]={fSSDAlTraceFlexMedium,fSSDStiffenerConnectorMedium,fSSDSn};
2396 TGeoVolume* ssdconnector[kssdconnectorlayernumber];
2397 for(Int_t i=0; i<kssdconnectorlayernumber; i++){
2398 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
bf210566 2399 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2400 0.5*fgkSSDConnectorWidth,
78e34526 2401 0.5*ssdConnectorThickness[i],
2402 ssdconnectororigin);
2403 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
bf210566 2404 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
78e34526 2405 ssdConnectorMedium[i]);
2406 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorNiSn);
bf210566 2407 }
78e34526 2408 const Int_t kssdconnectornumber = 4;
2409 TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
bf210566 2410 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2411 + fgkSSDConnectorPosition[0]
2412 - fgkSSDConnectorSeparation
2413 - 1.5*fgkSSDConnectorLength,
2414 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2415 - fgkSSDConnectorPosition[1]
2416 - ssdconnectorshape[0]->GetDY(),0.0);
2417 ssdconnectortrans[1] = new TGeoTranslation(
2418 - ssdstiffenershape->GetDX()
2419 + fgkSSDConnectorPosition[0]
2420 - 0.5*fgkSSDConnectorLength,
2421 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2422 - fgkSSDConnectorPosition[1]
2423 - ssdconnectorshape[0]->GetDY(),0.0);
2424 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2425 - fgkSSDConnectorPosition[0]
2426 + fgkSSDConnectorSeparation
2427 + 1.5*fgkSSDConnectorLength,
2428 -(ssdstiffenershape->GetDY()
2429 - fgkSSDConnectorPosition[1]
2430 - ssdconnectorshape[0]->GetDY()),0.0);
2431 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2432 - fgkSSDConnectorPosition[0]
2433 + 0.5*fgkSSDConnectorLength,
2434 -(ssdstiffenershape->GetDY()
2435 - fgkSSDConnectorPosition[1]
2436 - ssdconnectorshape[0]->GetDY()),0.0);
78e34526 2437 for(Int_t i=0; i<kssdconnectornumber; i++) {
2438 Int_t nlay = kssdconnectorlayernumber - 1;
2439 if (i == 1 || i == 2)
2440 nlay++;
2441 for(Int_t j=0; j<nlay; j++)
2442 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2443 }
bf210566 2444////////////////////////////
2445// Capacitor 1812-330 nF
2446///////////////////////////
78e34526 2447// Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2448 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2449 0.5*fgkSSDCapacitor1812Length,
2450 0.5*fgkSSDCapacitor1812Width,
78e34526 2451 0.5*fgkSSDCapacitor1812Height);
2452 // ssdcapacitor1812origin);
44285dfa 2453 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2454 fSSDStiffener1812CapacitorMedium);
2455 capacitor1812->SetLineColor(fColorAl);
bf210566 2456 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2457 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
78e34526 2458 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
bf210566 2459 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
78e34526 2460
2461 TGeoBBox* capacitor1812capshape = new TGeoBBox("Capacitor1812CapShape",
2462 0.5*fgkSSDCapacitor1812CapLength, 0.5*fgkSSDCapacitor1812Width,
2463 0.5*fgkSSDCapacitor1812Height);
2464 TGeoVolume* capacitor1812cap = new TGeoVolume("Capacitor1812Cap",capacitor1812capshape,
2465 fSSDStiffenerCapacitorCapMedium);
2466 capacitor1812cap->SetLineColor(fColorNiSn);
2467 TGeoTranslation* capacitor1812captrans1 = new TGeoTranslation(
2468 - capacitor1812shape->GetDX() - capacitor1812capshape->GetDX(),
2469 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2470 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2471 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2472 ssdhybridcapacitormother->AddNode(capacitor1812cap,1,capacitor1812captrans1);
2473 TGeoTranslation* capacitor1812captrans2 = new TGeoTranslation(
2474 capacitor1812shape->GetDX() + capacitor1812capshape->GetDX(),
2475 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2476 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2477 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2478 ssdhybridcapacitormother->AddNode(capacitor1812cap,2,capacitor1812captrans2);
2479
d7599219 2480////////////////////////////
2481//Hybrid Wire
2482////////////////////////////
44285dfa 2483 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2484 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2485 - fgkSSDConnectorSeparation;
44285dfa 2486 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2487 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
60e55aee 2488 Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2489
44285dfa 2490 Double_t wireangle = TMath::ATan(wirex/wirey);
2491 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2492 fgkSSDWireRadius, 0.5*ssdwireradius);
2493 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2494 fSSDStiffenerHybridWireMedium);
2495 hybridwire->SetLineColor(fColorPhynox);
2496 TGeoCombiTrans* hybridwirecombitrans[2];
2497 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2498 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2499 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2500 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2501 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2502 ssdstiffenershape->GetDZ()
78e34526 2503 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight+fgkSSDConnectorSnHeight,
d7599219 2504 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2505 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2506 0.0,
2507 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2508 0.0,
2509 new TGeoRotation("HybridWireRot2",
2510 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2511 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2512 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2513 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2514 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2515 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2516 /////////////////////////////////////////////////////////////
bf210566 2517 // Deallocating memory
44285dfa 2518 /////////////////////////////////////////////////////////////
bf210566 2519 delete hybridwirecombitrans[0];
2520 delete hybridwirecombitrans[1];
bf210566 2521 return ssdhybridlist;
2522 /////////////////////////////////////////////////////////////
2523}
2524///////////////////////////////////////////////////////////////////////////////
2525TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2526 /////////////////////////////////////////////////////////////
2527 // SSD Cooling Block System
2528 /////////////////////////////////////////////////////////////
2529 // SSD Cooling Block and Cooling Tube Transformations
2530 /////////////////////////////////////////////////////////////
2531 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2532 localcoolingblockrot->SetAngles(0.,90.,0.);
535e8862 2533 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
bf210566 2534 TVector3* coolingblocktransvector;
78e34526 2535 coolingblocktransvector = new TVector3(fgkCoolingTubeSeparation,
bf210566 2536 fgkSSDSensorLength
2537 - 2.*fgkSSDModuleStiffenerPosition[1]
c2aad3ae 2538 - fgkSSDCoolingBlockWidth, 0);
bf210566 2539 const Int_t kcoolingblocktransnumber = 2;
2540 const Int_t kcoolingblocknumber = 4;
2541 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
bf210566 2542 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2543 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
bf210566 2544 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
535e8862 2545 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
78e34526 2546 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X(),//+2*coolingtubedistance,
535e8862 2547 j*coolingblocktransvector->Y(),
2548 - 0.5*(fgkSSDCoolingBlockHoleCenter
2549 + fgkCoolingTubeRmax));
2550 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
535e8862 2551 }
d7599219 2552 }
ca86fdb4 2553 TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
bf210566 2554 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2555 /////////////////////////////////////////////////////////////
2556 // Adding Cooling block to mother volume
2557 /////////////////////////////////////////////////////////////
3cf6a656 2558 for(Int_t i=0; i<kcoolingblocknumber; i++){
2559 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
d7599219 2560 }
bf210566 2561 /////////////////////////////////////////////////////////////
2562 // Deallocating memory
2563 /////////////////////////////////////////////////////////////
3cf6a656 2564 delete coolingblocktransvector;
2565 delete localcoolingblockrot;
2566
2567 return coolingsystemother;
d7599219 2568}
2569/////////////////////////////////////////////////////////////////////////////////
bf210566 2570TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2571 /////////////////////////////////////////////////////////////
bf210566 2572 // SSD Flex
44285dfa 2573 /////////////////////////////////////////////////////////////
bf210566 2574 const Int_t kssdflexlayernumber = 2;
2575 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2576 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2577 const Int_t kmothervertexnumber = 17;
2578 Double_t xmothervertex[kmothervertexnumber];
2579 Double_t ymothervertex[kmothervertexnumber];
2580 /////////////////////////////////////////////
2581 // Auxiliary variables for vertex positioning
2582 /////////////////////////////////////////////
2583 const Int_t kssdflexboxnumber = 5;
44285dfa 2584 Double_t ssdflexboxlength[kssdflexboxnumber];
2585 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2586 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2587 * fgkSSDChipSeparationLength
2588 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2589 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2590 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2591 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2592 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2593 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2594 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2595 - ssdflexboxlength[1];
44285dfa 2596 Double_t ssdflexboxwidth[kssdflexboxnumber];
2597 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2598 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2599 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2600 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2601 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2602 ///////////////////////
2603 // Setting the vertices
2604 ///////////////////////
2605 xmothervertex[0] = 0.0;
2606 xmothervertex[1] = xmothervertex[0];
2607 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2608 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2609 + ssdflexboxlength[4];
2610 xmothervertex[4] = xmothervertex[3];
2611 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2612 xmothervertex[6] = xmothervertex[5];
2613 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2614 xmothervertex[8] = xmothervertex[7];
2615 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2616 xmothervertex[10] = xmothervertex[9];
2617 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2618 xmothervertex[12] = xmothervertex[11];
2619 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2620 xmothervertex[14] = xmothervertex[13];
2621 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2622 xmothervertex[16] = xmothervertex[15];
2623 ymothervertex[0] = 0.0;
2624 ymothervertex[1] = fgkSSDFlexWidth[1];
2625 ymothervertex[2] = fgkSSDFlexWidth[0];
2626 ymothervertex[3] = ymothervertex[2];
2627 ymothervertex[4] = ymothervertex[0];
2628 ymothervertex[5] = ymothervertex[4];
2629 ymothervertex[6] = ssdflexboxwidth[2];
2630 ymothervertex[7] = ymothervertex[6];
2631 ymothervertex[8] = ymothervertex[0];
2632 ymothervertex[9] = ymothervertex[8];
2633 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2634 ymothervertex[11] = ymothervertex[10];
2635 ymothervertex[12] = ymothervertex[0];
2636 ymothervertex[13] = ymothervertex[12];
2637 ymothervertex[14] = ymothervertex[7];
2638 ymothervertex[15] = ymothervertex[14];
2639 ymothervertex[16] = ymothervertex[0];
2640 /////////////////////////////////////////////////////////////
2641 // First Mother Volume containing SSDFlex
2642 /////////////////////////////////////////////////////////////
2643 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2644 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2645 ymothervertex);
2646 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2647 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
ca86fdb4 2648 TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2649// TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2650// fSSDAir);
bf210566 2651 /////////////////////////////////////////////////////////////
2652 // SSDFlex Layer Shapes
2653 /////////////////////////////////////////////////////////////
2654 for(Int_t i=0; i<kssdflexlayernumber; i++){
2655 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2656 ymothervertex);
2657 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2658 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2659 }
2660 /////////////////////////////////////
2661 // Setting Layers into Mother Volume
2662 /////////////////////////////////////
2663 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2664 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2665 fSSDKaptonFlexMedium};
2666 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2667 "AlFlexLay2","KaptonFlexLay2"};
2668 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2669 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2670 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2671 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2672 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2673 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2674 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2675 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2676 + fgkSSDFlexHeight[1]));
2677 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2678 }
bf210566 2679 return ssdflexmother;
d7599219 2680}
2681/////////////////////////////////////////////////////////////////////////////////
bf210566 2682TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2683 /////////////////////////////////////////////////////////////
2684 // Method generating SSD End Flex
d7599219 2685 /////////////////////////////////////////
bf210566 2686 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2687 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2688 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2689 * TMath::DegToRad()*ssdflexradiusmax
2690 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 2691 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2692 - 0.1*fgkSSDFlexFullLength;
bf210566 2693 const Int_t knedges = 20;
2694 const Int_t karcnumber = 2;
2695 TVector3* vertexposition[karcnumber*(knedges+1)];
2696 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2697 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2698 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2699 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2700 - 90.0*TMath::DegToRad()};
2701 TVector3* referencetrans[karcnumber];
2702 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2703 + radius[0]*SinD(2.*fgkSSDFlexAngle),
c2aad3ae 2704 radius[0], 0);
bf210566 2705 referencetrans[1] = new TVector3(referencetrans[0]->X()
2706 + fgkSSDFlexLength[2],
c2aad3ae 2707 - fgkSSDStiffenerHeight, 0);
bf210566 2708for(Int_t i=0; i<karcnumber; i++){
2709 for(Int_t j=0; j<knedges+1; j++){
2710 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
c2aad3ae 2711 radius[i]*SinD(angle[i]), 0);
bf210566 2712 angle[i] += deltangle[i]*(1.0-2.0*i);
2713 }
2714 }
2715 ///////////////////////
2716 // Setting the vertices
2717 ///////////////////////
2718 const Int_t kendflexlayernumber = 4;
2719 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2720 TVector3** vertex[kendflexlayernumber];
2721 for(Int_t i=0; i<kendflexlayernumber; i++)
2722 vertex[i] = new TVector3*[kendflexvertexnumber];
2723 TVector3* transvector[kendflexlayernumber+1];
2724 TVector3* deltatransvector = new TVector3();
2725 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2726 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2727 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2728 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2729 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2730 * CosD(fgkSSDFlexAngle),
2731 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2732 * SinD(fgkSSDFlexAngle),0.0);
2733 *transvector[i] = *transvector[i-1]+*deltatransvector;
2734 }
2735 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2736 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2737 for(Int_t i=0; i<karcnumber; i++){
2738 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2739 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2740 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2741 /radius[i];
2742 }
2743 }
2744 for(Int_t i=0; i<kendflexlayernumber; i++){
c2aad3ae 2745 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y(),0);
2746 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y(),0);
bf210566 2747 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2748 if(j<(knedges+1)){
2749 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
c2aad3ae 2750 vertexposition[j]->Y()*ratioradius[0][i+1], 0);
bf210566 2751 vertex[i][j+2]->RotateZ(referenceangle[0]);
2752 *vertex[i][j+2] += *referencetrans[0];
2753 vertex[i][4*(knedges+1)-j+1] =
2754 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
c2aad3ae 2755 vertexposition[j]->Y()*ratioradius[0][i], 0);
bf210566 2756 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2757 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2758 }
2759 else{
2760
2761 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
c2aad3ae 2762 vertexposition[j]->Y()*ratioradius[1][i+1],0);
bf210566 2763 vertex[i][j+2]->RotateZ(referenceangle[1]);
2764 *vertex[i][j+2] += *referencetrans[1];
2765 vertex[i][4*(knedges+1)-j+1] =
2766 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
c2aad3ae 2767 vertexposition[j]->Y()*ratioradius[1][i],
2768 0);
bf210566 2769 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2770 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2771 }
2772 }
2773 }
44285dfa 2774 /////////////////////////////////////////////////////////////
bf210566 2775 // First Mother Volume containing SSDEndFlex
2776 /////////////////////////////////////////////////////////////
2777 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2778 Double_t xmothervertex[kendflexvertexnumber];
2779 Double_t ymothervertex[kendflexvertexnumber];
2780 xmothervertex[0] = vertex[0][0]->X();
2781 ymothervertex[0] = vertex[0][0]->Y();
2782 for(Int_t i=1; i<kendflexvertexnumber; i++){
2783 if(i<2*(knedges+1)+2){
2784 xmothervertex[i] = vertex[3][i]->X();
2785 ymothervertex[i] = vertex[3][i]->Y();
2786 }
2787 else{
2788 xmothervertex[i] = vertex[0][i]->X();
2789 ymothervertex[i] = vertex[0][i]->Y();
2790 }
2791 }
2792 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2793 xmothervertex,ymothervertex);
2794 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2795 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
0fb26117 2796// TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2797// ssdendflexmothershape,fSSDAir);
2798 TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
bf210566 2799 //////////////////////////////////////
2800 // End Flex TGeoXtru Layer Definition
2801 //////////////////////////////////////
2802 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2803 TGeoVolume* ssdendflex[kendflexlayernumber];
2804 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2805 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2806 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2807 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2808 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2809 fSSDKaptonFlexMedium};
2810 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2811 "AlEndFlexLay2","KaptonEndFlexLay2"};
2812 for(Int_t i=0; i<kendflexlayernumber; i++){
2813 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2814 xvertex[i][j] = vertex[i][j]->X();
2815 yvertex[i][j] = vertex[i][j]->Y();
2816 }
2817 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2818 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2819 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2820 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2821 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2822 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2823 ssdendflexmother->AddNode(ssdendflex[i],1);
2824 }
44285dfa 2825 /////////////////////////////////////////////////////////////
bf210566 2826 // Deallocating memory
44285dfa 2827 /////////////////////////////////////////////////////////////
bf210566 2828 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2829 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2830 for(Int_t i=0; i<kendflexlayernumber; i++){
2831 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2832 delete [] vertex[i];
2833 }
2834 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2835 delete deltatransvector;
44285dfa 2836 /////////////////////////////////////////////////////////////
6727e2db 2837 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 2838 return ssdendflexmother;
d7599219 2839}
9b0c60ab 2840///////////////////////////////////////////////////////////////////////////////
bf210566 2841TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 2842 /////////////////////////////////////////////////////////////
9b0c60ab 2843 // Method generating the Mounting Block
bf210566 2844 /////////////////////////////////////////////////////////////
9b0c60ab 2845 const Int_t kvertexnumber = 8;
2846 Double_t xvertex[kvertexnumber];
2847 Double_t yvertex[kvertexnumber];
2848 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2849 xvertex[1] = xvertex[0];
2850 xvertex[2] = -xvertex[0];
2851 xvertex[3] = xvertex[2];
2852 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2853 - fgkSSDMountingBlockLength[2]);
2854 xvertex[5] = xvertex[4];
2855 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2856 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2857 - fgkSSDMountingBlockScrewHoleRadius[0];
2858 xvertex[7] = xvertex[6];
2859 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 2860 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 2861 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2862 yvertex[2] = yvertex[1];
2863 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2864 yvertex[4] = yvertex[3];
2865 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2866 - fgkSSDMountingBlockHeight[0];
2867 yvertex[6] = yvertex[5];
2868 yvertex[7] = yvertex[0];
160835d5 2869
9b0c60ab 2870 ///////////////////////////////////////////////////////////////////////
2871 // TGeoXTru Volume definition for Mounting Block Part
2872 ///////////////////////////////////////////////////////////////////////
2873 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2874 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2875 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2876 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 2877 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 2878 ssdmountingblockshape,
2879 fSSDMountingBlockMedium);
2880 ssdmountingblock->SetLineColor(fColorG10);
2881 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2882 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2883 TGeoRotation* mountingblockrot = new TGeoRotation();
2884 mountingblockrot->SetAngles(90.,180.,-90.);
2885 mountingblockcombitrans->SetRotation(*mountingblockrot);
2886 /////////////////////////////////////////////////////////////
2887 // Generating the Mounting Block Screw Vertices
2888 /////////////////////////////////////////////////////////////
2889 const Int_t kscrewvertexnumber = 15;
2890 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
2891 - fgkSSDMountingBlockScrewHoleEdge)
2892 / fgkSSDMountingBlockScrewHoleRadius[0])
2893 * TMath::RadToDeg();
2894 Double_t phi0 = 90.+alpha;
2895 Double_t phi = 270.-2*alpha;
2896 Double_t deltaphi = phi/kscrewvertexnumber;
2897 TVector3* screwvertex[kscrewvertexnumber+1];
2898 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
2899 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
2900 *CosD(phi0+i*deltaphi),
2901 fgkSSDMountingBlockScrewHoleRadius[0]
c2aad3ae 2902 *SinD(phi0+i*deltaphi), 0);
9b0c60ab 2903 Double_t xscrewvertex[kscrewvertexnumber+6];
2904 Double_t yscrewvertex[kscrewvertexnumber+6];
2905 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
2906 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
2907 - fgkSSDMountingBlockScrewHoleEdge);
2908 xscrewvertex[1] = xscrewvertex[0];
2909 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2910 xscrewvertex[2] = screwvertex[0]->X();
2911 yscrewvertex[2] = yscrewvertex[1];
2912 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
2913 xscrewvertex[i+3] = screwvertex[i]->X();
2914 yscrewvertex[i+3] = screwvertex[i]->Y();
2915 }
2916 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2917 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
2918 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
2919 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
2920 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
2921 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
2922 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
2923 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
2924 + fgkSSDMountingBlockHeight[2]);
2925 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
2926 ssdmountingblockscrewshape,
2927 fSSDMountingBlockMedium);
2928 ssdmountingblockscrew->SetLineColor(fColorG10);
2929 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
2930 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
2931 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2932 - yscrewvertex[1],
2933 0.5*fgkSSDMountingBlockHeight[0]
2934 - fgkSSDMountingBlockHeight[2]
2935 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2936 + fgkSSDMountingBlockHeight[2]
2937 - yvertex[0]));
2938 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2939 -0.5*fgkSSDMountingBlockScrewHoleEdge,
2940 yscrewvertex[1]
2941 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2942 +fgkSSDMountingBlockHeight[2]
2943 -yvertex[0]));
2944 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2945 yscrewvertex[1],
2946 - 0.5*fgkSSDMountingBlockHeight[0]
2947 + fgkSSDMountingBlockHeight[2]
2948 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2949 + fgkSSDMountingBlockHeight[2]
2950 - yvertex[0]));
2951 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2952 yscrewvertex[1],
2953 - yscrewvertex[1]
2954 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2955 + fgkSSDMountingBlockHeight[2]
2956 - yvertex[0]));
2957 TGeoRotation* ssdmountingblockscrewrot[4];
2958 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
2959 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
2960 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
2961 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
2962 for(Int_t i=1; i<4; i++)
2963 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
2964 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
2965 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
2966 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
2967 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
2968 + xvertex[0],yscrewvertex[1]
2969 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2970 + fgkSSDMountingBlockHeight[2]
2971 - yvertex[0]),0.);
2972 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
2973 for(Int_t i=0; i<4; i++){
2974 ssdmountingblockscrewmatrix[i] =
2975 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
2976 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
2977 }
2978 ///////////////////////////////////////////////////////////////////////
2979 // TGeoXtru for Mother Volume
2980 ///////////////////////////////////////////////////////////////////////
2981 const Int_t kvertexmothernumber = 12;
2982 Double_t xmothervertex[kvertexmothernumber];
2983 Double_t ymothervertex[kvertexmothernumber];
2984 for(Int_t i=0; i<6; i++){
2985 xmothervertex[i] = xvertex[i];
2986 ymothervertex[i] = yvertex[i];
2987 }
2988 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
2989 ymothervertex[6] = ymothervertex[5];
2990 xmothervertex[7] = xmothervertex[6];
5d9d4033 2991 ymothervertex[7] = ymothervertex[4] - fgkSSDTolerance;
9b0c60ab 2992 xmothervertex[8] = xmothervertex[7]
2993 + 0.5*(fgkSSDMountingBlockLength[1]
2994 - fgkSSDMountingBlockLength[2]);
5d9d4033 2995 ymothervertex[8] = ymothervertex[7];
9b0c60ab 2996 xmothervertex[9] = xmothervertex[8];
2997 ymothervertex[9] = ymothervertex[2];
2998 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
2999 ymothervertex[10] = ymothervertex[1];
3000 xmothervertex[11] = xmothervertex[10];
3001 ymothervertex[11] = ymothervertex[0];
3002 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3003 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3004 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3005 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3006 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3007 ssdmountingblockmothershape,
3008 fSSDAir);
3009 /////////////////////////////////////////////////////////////
3010 // Placing the Volumes into Mother Volume
3011 /////////////////////////////////////////////////////////////
3012 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3013 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3014 for(Int_t i=0; i<4; i++)
3015 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3016 ssdmountingblockscrewmatrix[i]);
3017 /////////////////////////////////////////////////////////////
3018 // Deallocating memory
3019 /////////////////////////////////////////////////////////////
3020 delete mountingblockrot;
3021 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3022 delete ssdmountingblockglobalrot;
3023 delete ssdmountingblockglobaltrans;
3024 /////////////////////////////////////////////////////////////
3025 return ssdmountingblockmother;
3026}
3027///////////////////////////////////////////////////////////////////////////////
3028 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3029 /////////////////////////////////////////////////////////////
3030 // Method generating the Mounting Block Clip
3031 /////////////////////////////////////////////////////////////
3032 const Int_t kmothervertexnumber = 10;
3033 Double_t xmothervertex[kmothervertexnumber];
3034 Double_t ymothervertex[kmothervertexnumber];
3035 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3036 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3037 xmothervertex[1] = xmothervertex[0];
3038 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3039 - fgkMountingBlockClibScrewRadius);
3040 xmothervertex[3] = xmothervertex[2];
3041 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3042 xmothervertex[5] = xmothervertex[4];
3043 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3044 xmothervertex[7] = xmothervertex[6];
3045 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3046 xmothervertex[9] = xmothervertex[8];
3047 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 3048 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 3049 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3050 ymothervertex[2] = ymothervertex[1];
3051 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3052 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3053 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3054 ymothervertex[4] = ymothervertex[3];
3055 ymothervertex[5] = ymothervertex[2];
3056 ymothervertex[6] = ymothervertex[5];
3057 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3058 ymothervertex[8] = ymothervertex[7];
3059 ymothervertex[9] = ymothervertex[0];
160835d5 3060
9b0c60ab 3061 ///////////////////////////////////////////////////////////////////////
3062 // TGeoXTru Volume definition for Mounting Block Clip Part
3063 ///////////////////////////////////////////////////////////////////////
3064 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3065 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3066 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3067 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3068 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3069 ssdmountingblockclipshape,fSSDAir);
3070 ssdmountingblockclip->SetLineColor(4);
3071 ///////////////////////////////////////////////////////////////////////
3072 // TGeoXTru Volume definition for Clip
3073 ///////////////////////////////////////////////////////////////////////
3074 const Int_t kclipvertexnumber = 6;
3075 Double_t xclipvertex[kclipvertexnumber];
3076 Double_t yclipvertex[kclipvertexnumber];
3077 xclipvertex[0] = xmothervertex[0];
3078 xclipvertex[1] = xclipvertex[0];
3079 xclipvertex[2] = xmothervertex[6];
3080 xclipvertex[3] = xclipvertex[2];
3081 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3082 xclipvertex[5] = xclipvertex[4];
3083 yclipvertex[0] = ymothervertex[0];
3084 yclipvertex[1] = ymothervertex[1];
3085 yclipvertex[2] = yclipvertex[1];
3086 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3087 yclipvertex[4] = yclipvertex[3];
3088 yclipvertex[5] = yclipvertex[0];
3089 TGeoXtru* clipshape = new TGeoXtru(2);
3090 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3091 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3092 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3093 + fgkMountingBlockClibWidth);
3094 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3095 clip->SetLineColor(18);
3096 ///////////////////////////////////////////////////////////////////////
3097 // Ladder Support Piece
3098 ///////////////////////////////////////////////////////////////////////
3099 const Int_t ksupportvertexnumber = 4;
3100 Double_t xsupportvertex[ksupportvertexnumber];
3101 Double_t ysupportvertex[ksupportvertexnumber];
3102 xsupportvertex[0] = xclipvertex[5];
3103 xsupportvertex[1] = xsupportvertex[0];
3104 xsupportvertex[2] = xmothervertex[9];
3105 xsupportvertex[3] = xsupportvertex[2];
3106 ysupportvertex[0] = yclipvertex[0];
3107 ysupportvertex[1] = yclipvertex[3];
3108 ysupportvertex[2] = ysupportvertex[1];
3109 ysupportvertex[3] = ysupportvertex[0];
3110 TGeoXtru* supportshape = new TGeoXtru(2);
3111 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3112 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3113 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3114 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3115 support->SetLineColor(9);
3116 ///////////////////////////////////////////////////////////////////////
3117 // TGeoXTru Volume definition for Screw
3118 ///////////////////////////////////////////////////////////////////////
3119 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3120 0.5*fgkMountingBlockClibScrewRadius};
3121 Int_t edgesnumber[2] = {50,6};
3122 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3123 +0.5*(ymothervertex[3]-ymothervertex[2])};
851c0ce3 3124 TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
9b0c60ab 3125 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3126 clipscrew->SetLineColor(12);
3127 TGeoRotation* screwrot = new TGeoRotation();
3128 screwrot->SetAngles(0.,90.,0.);
3129 TGeoTranslation* screwtrans = new TGeoTranslation();
3130 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3131 0.5*(ymothervertex[3]+ymothervertex[2]),
3132 0.5*fgkSSDMountingBlockWidth+
3133 -0.5*fgkMountingBlockSupportWidth[0]);
3134 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3135 ///////////////////////////////////////////////////////////////////////
3136 // Placing the Volumes
3137 ///////////////////////////////////////////////////////////////////////
3138 ssdmountingblockclip->AddNode(clip,1);
3139 ssdmountingblockclip->AddNode(support,1);
3140 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3141 /////////////////////////////////////////////////////////////
3142 // Deallocating memory
3143 /////////////////////////////////////////////////////////////
3144 delete screwtrans;
3145 delete screwrot;
3146 /////////////////////////////////////////////////////////////
3147 return ssdmountingblockclip;
d7599219 3148}
bf210566 3149///////////////////////////////////////////////////////////////////////////////
cd2243fb 3150void AliITSv11GeometrySSD::CreateCoolingTubes() {
44285dfa 3151 /////////////////////////////////////////////////////////////
bf210566 3152 // Method generating the Cooling Tube
cd2243fb 3153 // sets fcoolingtube and returns list for endladdercoolingtube
44285dfa 3154 /////////////////////////////////////////////////////////////
cd2243fb 3155 TGeoTube *coolingtubeshape[2];
3156 // Ladder Cooling Tubes
3157
3158 // MvL: Simplified cooling tubes
3159 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
3160 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
3161
3162 // End Ladder Cooling Tubes
3163 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3164 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3165 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3166
3167 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
3168 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3169 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
3170 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3171 endladdercoolingtubeshape[0][0]->GetDz());
3172 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3173 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
3174 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3175 endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
3176 // Ladder Cooling Tubes
3177 TGeoVolume* coolingtube[2];
3178 coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
3179 coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
3180 coolingtube[0]->SetLineColor(fColorPhynox);
3181 coolingtube[1]->SetLineColor(fColorWater);
3182
3183 // End Ladder Cooling Tubes
3184 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3185 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3186 endladdercoolingtube[i] = new TGeoVolume*[2];
3187 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3188 endladdercoolingtubeshape[0][0],
3189 fSSDCoolingTubePhynox);
3190 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3191 endladdercoolingtubeshape[0][1],
3192 fSSDCoolingTubeWater);
3193 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3194 endladdercoolingtubeshape[1][0],
3195 fSSDCoolingTubePhynox);
3196 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3197 endladdercoolingtubeshape[1][1],
3198 fSSDCoolingTubeWater);
3199 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3200 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3201 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3202 }
0fb26117 3203
bf210566 3204 /////////////////////////////////////////////////////////////
3205 // Virtual Volume containing Cooling Tubes
3206 /////////////////////////////////////////////////////////////
9b0c60ab 3207 // Ladder Cooling Tubes
cd2243fb 3208 TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
3209 coolingtubeshape[0]->GetRmax(),
3210 coolingtubeshape[0]->GetDz());
3211 fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
3212 fcoolingtube->AddNode(coolingtube[0],1);
3213 fcoolingtube->AddNode(coolingtube[1],1);
3214
9b0c60ab 3215 // End Ladder Cooling Tubes
3216 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3217 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
cd2243fb 3218 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3219 endladdercoolingtubeshape[i][0]->GetRmax(),
3220 endladdercoolingtubeshape[i][0]->GetDz());
3221 fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3222 endladdervirtualcoolingtubeshape[0],
3223 fSSDAir);
3224 fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3225 endladdervirtualcoolingtubeshape[1],
3226 fSSDAir);
3227 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3228 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3229 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3230 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
d7599219 3231}
bf210566 3232///////////////////////////////////////////////////////////////////////////////
3233TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3234 /////////////////////////////////////////////////////////////
bf210566 3235 // Method generating SSD Cooling Block
44285dfa 3236 /////////////////////////////////////////////////////////////
bf210566 3237 const Int_t kvertexnumber = 8;
3238 ///////////////////////////////////////
3239 // Vertex Positioning for TGeoXTru
3240 ///////////////////////////////////////
3241 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
c2aad3ae 3242 vertexposition[0] = new TVector3(0.0,0.0, 0.);
3243 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1],0);
bf210566 3244 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
c2aad3ae 3245 vertexposition[1]->Y(),0);
bf210566 3246 vertexposition[3] = new TVector3(vertexposition[2]->X(),
c2aad3ae 3247 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2],0);
3248 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y(),0);
bf210566 3249 vertexposition[5] = new TVector3(vertexposition[4]->X(),
c2aad3ae 3250 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1],0);
bf210566 3251 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3252 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3253 - fgkSSDCoolingBlockHoleLength[0]
3254 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3255 fgkSSDCoolingBlockHeight[0]
3256 - fgkSSDCoolingBlockHoleRadius[1],
c2aad3ae 3257 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0], 0);
bf210566 3258 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3259 - fgkSSDCoolingBlockHoleLength[0]),
c2aad3ae 3260 vertexposition[6]->Y(), 0);
bf210566 3261 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3262 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3263 Double_t phi = 180.-alpha;
3264 Double_t psi = 180.+2.*alpha;
3265 Double_t deltapsi = psi/nedges;
3266 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3267 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
c2aad3ae 3268 fgkSSDCoolingBlockHoleCenter, 0);
bf210566 3269 for(Int_t i=0; i<nedges+1; i++){
3270 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
c2aad3ae 3271 radius*SinD(phi+i*deltapsi),
3272 0);
bf210566 3273 *vertexposition[kvertexnumber+i] += (*transvector);
3274 }
3275 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3276 for(Int_t i=0; i<kvertexnumber; i++)
3277 vertexposition[kvertexnumber+nedges+1+i] =
3278 GetReflection(vertexposition[kvertexnumber-1-i],param);
3279 ///////////////////////////////////////////////////////////////////////
3280 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3281 ///////////////////////////////////////////////////////////////////////
3282 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3283 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3284 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3285 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3286 xvertexpoints[i] = vertexposition[i]->X();
3287 yvertexpoints[i] = vertexposition[i]->Y();
3288 }
3289 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3290 yvertexpoints);
3291 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3292 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3293 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3294 ssdcoolingblockshape,
3295 fSSDAlCoolBlockMedium);
3296 ssdcoolingblock->SetLineColor(fColorAl);
3297 /////////////////////////////////////////////////////////////
3298 // Deallocating memory
3299 /////////////////////////////////////////////////////////////
3300 delete [] vertexposition;
7b208ef4 3301 delete [] xvertexpoints;
3302 delete [] yvertexpoints;
bf210566 3303 /////////////////////////////////////////////////////////////
3304 return ssdcoolingblock;
3305}
3306/////////////////////////////////////////////////////////////////////////////////
3cf6a656 3307void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
d7599219 3308 ///////////////////////////////////////////////////////
cd2243fb 3309 static const Int_t kssdchipcablesnumber = 2; // Number of cables: left and right
3310 static const Int_t kssdchipcableslaynumber = 2; // Number of layers: Al and Kapton
3311 static const Int_t kvertexnumber = 4*(nedges+1)+4;
bf210566 3312 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3313 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
cd2243fb 3314 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
bf210566 3315 - fgkSSDChipCablesHeight[0]
3316 - fgkSSDChipCablesHeight[1]);
3317 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3318 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3319 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3320 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3321 - ssdchipcablesradius[0]
3322 - fgkSSDChipCablesWidth[1]
3323 - fgkSSDChipCablesWidth[2]);
3324 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3325 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3326 + fgkSSDChipCablesHeight[1]
3327 + fgkSSDSensorHeight);
d7599219 3328 ///////////////////////////////////////////////////////
bf210566 3329 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3330 ///////////////////////////////////////////////////////
3331 TVector3** vertexposition[kssdchipcableslaynumber];
3332 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3333 new TVector3*[4*(nedges+1)+4];
3334 Double_t ratio[4];
3335 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3336 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3337 / ssdchipcablesradius[0];
3338 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3339 / ssdchipcablesradius[0];
3340 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3341 + fgkSSDChipCablesHeight[1])
3342 / ssdchipcablesradius[0];
3343 Double_t phi = 180.;
3344 Double_t deltaphi = 180./nedges;
3345 Double_t angle = 0.0;
045be90c 3346
3347 Double_t xvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3348 Double_t yvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3349
bf210566 3350 TVector3* vertex = new TVector3();
3351 TVector3* transvector[kssdchipcableslaynumber];
3352 transvector[0] = new TVector3(fgkSSDChipWidth,
c2aad3ae 3353 SSDChipCablesHeight-ssdchipcablesradius[0], 0);
bf210566 3354 transvector[1] = new TVector3();
cd2243fb 3355 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
3356 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
3357 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
bf210566 3358 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3359 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3360 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3361 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3362 transvector[1]->SetY(ssdchipcablesradius[0]
3363 + fgkSSDChipCablesHeight[0]
3364 + fgkSSDChipCablesHeight[1]);
3365 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
cd2243fb 3366 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
c2aad3ae 3367 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1], 0);
cd2243fb 3368 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
c2aad3ae 3369 - i*fgkSSDChipCablesHeight[0], 0);
bf210566 3370 vertexposition[i][2*(nedges+1)+2] =
3371 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3372 + fgkSSDChipCablesWidth[1]
3373 + fgkSSDChipCablesWidth[2],
3374 ((1.-i)*fgkSSDChipCablesHeight[i]
c2aad3ae 3375 + fgkSSDChipCablesHeight[1]), 0);
bf210566 3376 vertexposition[i][2*(nedges+1)+3] =
3377 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3378 vertexposition[i][2*(nedges+1)+2]->Y()
c2aad3ae 3379 - fgkSSDChipCablesHeight[i], 0);
bf210566 3380 for(Int_t j=0; j<nedges+1; j++){
3381 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3382 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3383 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3384 vertexposition[0][(nedges+1)*i+j+2] =
3385 new TVector3(*vertex+*transvector[i]);
3386 vertexposition[1][(nedges+1)*i+j+2] =
3387 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
c2aad3ae 3388 vertex->Y()*ratio[2*i]+transvector[i]->Y(), 0);
bf210566 3389 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3390 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3391 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3392 new TVector3(vertex->X()*ratio[2*i+1]
3393 + transvector[i]->X(),
3394 vertex->Y()*ratio[2*i+1]
c2aad3ae 3395 + transvector[i]->Y(), 0);
bf210566 3396 }
3397 }
3398 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3399 for(Int_t j=0; j<kvertexnumber; j++){
3400 xvertexpoints[i][j] = vertexposition[i][j]->X();
3401 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3402 }
3403 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3404 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3405 xvertexpoints[i],yvertexpoints[i]);
3406 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3407 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3408 ssdchipcable[kssdchipcablesnumber*k+i] =
3409 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3410 ssdchipcableshape[kssdchipcablesnumber*k+i],
3411 (kssdchipcablesnumber*k+i)%2==0?
3412 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3413 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3414 }
3415 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3416 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3417 }
44285dfa 3418 /////////////////////////////////////////////////////////////
bf210566 3419 // Mother Volume definition
3420 /////////////////////////////////////////////////////////////
cd2243fb 3421 static const Int_t kmothervertexnumber = 8;
3422 Double_t xmothervertex[kmothervertexnumber];
3423 Double_t ymothervertex[kmothervertexnumber];
3424 xmothervertex[0] = xvertexpoints[0][1];
3425 ymothervertex[0] = yvertexpoints[0][1];
3426 xmothervertex[1] = xvertexpoints[0][2+nedges/2];
3427 ymothervertex[1] = yvertexpoints[0][1];
3428 xmothervertex[2] = xvertexpoints[0][2+nedges/2];
3429 ymothervertex[2] = yvertexpoints[0][2+nedges];
3430 xmothervertex[3] = xvertexpoints[0][3+nedges];
3431 ymothervertex[3] = yvertexpoints[0][3+nedges];
3432 xmothervertex[4] = xvertexpoints[0][3+2*nedges];
5d9d4033 3433 ymothervertex[4] = yvertexpoints[0][3+2*nedges]+fgkSSDTolerance;
cd2243fb 3434 xmothervertex[5] = xvertexpoints[0][4+2*nedges];
5d9d4033 3435 ymothervertex[5] = yvertexpoints[0][4+2*nedges]+fgkSSDTolerance;
cd2243fb 3436 xmothervertex[6] = xvertexpoints[1][5+2*nedges];
3437 ymothervertex[6] = yvertexpoints[1][5+2*nedges];
3438 xmothervertex[7] = xvertexpoints[0][1];
3439 ymothervertex[7] = yvertexpoints[1][5+2*nedges];
3440 TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
3441 ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3442 ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3443 ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3444
3cf6a656 3445 cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
3446 cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
cd2243fb 3447
3cf6a656 3448 cableL->AddNode(ssdchipcable[0],1);
3449 cableL->AddNode(ssdchipcable[1],1);
3450 cableR->AddNode(ssdchipcable[2],1);
3451 cableR->AddNode(ssdchipcable[3],1);
cd2243fb 3452
bf210566 3453 /////////////////////////////////////////////////////////////
3454 // Deallocating memory
3455 /////////////////////////////////////////////////////////////
bf210566 3456 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3457 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3458 delete vertex;
bf210566 3459 /////////////////////////////////////////////////////////////
d7599219 3460}
5bf92139 3461//_____________________________________________________________________________
3cf6a656 3462TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
44285dfa 3463 /////////////////////////////////////////////////////////////
bf210566 3464 // SSD Chip Assembly Generation
3465 /////////////////////////////////////////////////////////////
bf210566 3466 TGeoBBox* ssdchipcompshape[2];
3467 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3468 0.5*fgkSSDChipLength,
3469 0.5*fgkSSDChipWidth,
3470 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3471 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3472 0.5*fgkSSDChipLength,
3473 0.5*fgkSSDChipWidth,
3474 0.5*fgkSSDChipGlueHeight);
3475 TGeoVolume* ssdchipcomp[2];
3476 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3477 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3478 fSSDChipGlueMedium);
3479 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3480 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3481 TGeoTranslation* ssdchipcomptrans[2];
3482 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3483 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3484 /////////////////////////////////////////////////////////////
3485 // Virtual Volume containing SSDChip
3486 /////////////////////////////////////////////////////////////
3487 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3488 0.5*fgkSSDChipWidth,
3489 0.5*fgkSSDChipHeight);
e21cdd03 3490 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
bf210566 3491 /////////////////////////////////////////////////////////////
3492 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3cf6a656 3493 return ssdchip;
d7599219 3494}
bf210566 3495/////////////////////////////////////////////////////////////////////////////////
3496TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3497 /////////////////////////////////////////////////////////////
bf210566 3498 // Method returning a List containing pointers to Ladder Cable Volumes
cd2243fb 3499 //
3500 // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
3501 // each contains 2 volumes, one for polyamide and one for aluminium
44285dfa 3502 /////////////////////////////////////////////////////////////
bf210566 3503 const Int_t kladdercablesegmentnumber = 2;
3504 /////////////////////////////////////////
3505 // LadderSegmentBBox Volume
3506 /////////////////////////////////////////
160835d5 3507 static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
bf210566 3508 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3509 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
160835d5 3510
3511
3512 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3513 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3514 static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3515
3516 static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
3517 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3518 0.5*fgkSSDFlexWidth[0],
3519 0.5*fgkSSDLadderCableWidth,
78e34526 3520 0.5*fgkSSDLadderCableHeight[0]),
160835d5 3521 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3522 0.5*fgkSSDFlexWidth[0],
3523 0.5*fgkSSDLadderCableWidth,
78e34526 3524 fgkSSDLadderCableHeight[0]
3525 +0.5*fgkSSDLadderCableHeight[1])
160835d5 3526 };
3527 static TGeoVolume* laddercablesegmentbboxassembly = new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
3528 static TGeoVolume* laddercablesegmentarbassembly =
3529 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3530
3531 static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3532 static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3533
3534 if (laddercablesegmentbboxshape[0] == 0) {
3535 // Initialise static shapes and volumes
bf210566 3536 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3537 new TGeoBBox(laddercablesegmentbboxshapename[i],
3538 0.5*fgkSSDFlexWidth[0],
3539 0.5*fgkSSDLadderCableWidth,
78e34526 3540 0.5*fgkSSDLadderCableHeight[i]);
160835d5 3541
bf210566 3542 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3543 laddercablesegmentbbox[i] =
3544 new TGeoVolume(laddercablesegmentbboxname[i],
3545 laddercablesegmentbboxshape[i],
3546 (i==0?fSSDAlTraceLadderCableMedium:
3547 fSSDKaptonLadderCableMedium));
3548 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3549 fColorPolyhamide);
3550 }
160835d5 3551
bf210566 3552 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3553 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3554 laddercablesegmentbboxtrans[i]);
3555/////////////////////////////////////////
3556// LadderSegmentArb8 Volume
3557/////////////////////////////////////////
3558 const Int_t kvertexnumber = 4;
3559 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3560 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3561 new TVector3*[kvertexnumber];
3562//Shape Vertex Positioning
3563 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
c2aad3ae 3564 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0], 0);
bf210566 3565 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
c2aad3ae 3566 i*fgkSSDFlexHeight[0], 0);
bf210566 3567 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3568 + fgkSSDFlexHeight[1]
c2aad3ae 3569 + i*fgkSSDFlexHeight[0], 0);
bf210566 3570 laddercablesegmentvertexposition[i][3] =
3571 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
c2aad3ae 3572 laddercablesegmentvertexposition[i][2]->Y(), 0);
bf210566 3573 }
3574 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3575 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
a6e0ebfe 3576 const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
bf210566 3577 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
160835d5 3578
bf210566 3579 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3580 GetArbShape(laddercablesegmentvertexposition[i],
3581 laddercablesegmentwidth[i],
3582 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3583 laddercablesegmentarbshapename[i]);
3584 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3585 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
160835d5 3586
bf210566 3587 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3588 laddercablesegmentarb[i] =
3589 new TGeoVolume(laddercablesegmentarbname[i],
3590 laddercablesegmentarbshape[i],
3591 (i==0?fSSDAlTraceLadderCableMedium:
3592 fSSDKaptonLadderCableMedium));
3593 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3594 fColorPolyhamide);
d7599219 3595}
bf210566 3596 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3597 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3598 90.,90,-90.);
3599 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3600 0.,90.,0.);
3601 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3602 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3603 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3604 + fgkSSDFlexWidth[0],0.,0.,
3605 new TGeoRotation((*laddercablesegmentarbrot[1])
3606 *(*laddercablesegmentarbrot[0])));
bf210566 3607 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3608 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3609 laddercablesegmentarbcombitrans);
160835d5 3610 } // End of static initialisations
bf210566 3611/////////////////////////////////////////
3612// End Ladder Cable Volume
160835d5 3613// Note: this part depends explicitly on the length passed as an argument to the function
bf210566 3614/////////////////////////////////////////
3615 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3616 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3617 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3618 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3619 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3620 0.5*ssdendladdercablelength,
3621 0.5*fgkSSDLadderCableWidth,
78e34526 3622 0.5*fgkSSDLadderCableHeight[i]);
bf210566 3623 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3624 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3625 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3626 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3627 ladderendcablesegmentbbox[i] =
3628 new TGeoVolume(ladderendcablesegmentbboxname[i],
3629 ladderendcablesegmentbboxshape[i],
3630 (i==0?fSSDAlTraceLadderCableMedium:
3631 fSSDKaptonLadderCableMedium));
3632 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3633 fColorPolyhamide);
3634 }
3635 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3636 ladderendcablesegmentbboxtrans[0] =
3637 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
3638 0.5*ssdendladdercablelength,
3639 0.5*fgkSSDLadderCableWidth,
78e34526 3640 0.5*fgkSSDLadderCableHeight[0]);
bf210566 3641 ladderendcablesegmentbboxtrans[1] =
3642 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
3643 0.5*ssdendladdercablelength,
3644 0.5*fgkSSDLadderCableWidth,
78e34526 3645 fgkSSDLadderCableHeight[0]
3646 +0.5*fgkSSDLadderCableHeight[1]);
bf210566 3647 TGeoVolume* ladderendcablesegmentbboxassembly =
3648 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
3649 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3650 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
3651 ladderendcablesegmentbboxtrans[i]);
3652/////////////////////////////////////////
3653 TList* laddercablesegmentlist = new TList();
3654 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
3655 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
3656 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
3657 return laddercablesegmentlist;
160835d5 3658}
3659
bf210566 3660/////////////////////////////////////////////////////////////////////////////////
3661TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 3662 /////////////////////////////////////////////////////////////
cd2243fb 3663 // Method generating Ladder Cable of given length (n modules + end)
3664 // Called by GetLadderCableAssembly
44285dfa 3665 /////////////////////////////////////////////////////////////
bf210566 3666 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
3667 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
3668 for(Int_t i=0; i<n; i++){
3669 TGeoTranslation* laddercabletrans = new TGeoTranslation(
3670 i*(fgkCarbonFiberJunctionWidth),
3671 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
78e34526 3672 i*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
bf210566 3673 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
cd2243fb 3674 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
3675
d7599219 3676 }
bf210566 3677 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
3678 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
cd2243fb 3679 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
78e34526 3680 (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
bf210566 3681 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
3682 return laddercable;
3683}
3684/////////////////////////////////////////////////////////////////////////////////
3685TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
cd2243fb 3686 ///////////////////////////////////////////////////////////////////
3687 // Main method generating Ladder Cable bundles containing n cables
3688 ///////////////////////////////////////////////////////////////////
3689 Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
78e34526 3690 Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])};
3691 TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]),cableOrig);
cd2243fb 3692 TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
a3f8715e 3693 char laddercabletransname[100];
bf210566 3694 for(Int_t i=0; i<n; i++){
045be90c 3695 snprintf(laddercabletransname,100,"LadderCableTrans%i",i+1);
3696 laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
3697 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
d7599219 3698 }
cd2243fb 3699 return laddercable;
bf210566 3700}
3701/////////////////////////////////////////////////////////////////////////////////
3702TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
3703 /////////////////////////////////////////////////////////////
3704 // Method generating Ladder Cable List Assemblies
cd2243fb 3705 // containing two cables bundles, i.e. P+N readout for one endcap
bf210566 3706 /////////////////////////////////////////////////////////////
cd2243fb 3707 const Int_t kladdercableassemblynumber = 2;
bf210566 3708 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
3709 TGeoVolume* ladderCable[kladdercableassemblynumber];
a3f8715e 3710 char laddercableassemblyname[100];
bf210566 3711 TList* laddercableassemblylist = new TList();
3712 for(Int_t i=0; i<kladdercableassemblynumber; i++){
045be90c 3713 snprintf(laddercableassemblyname,100,"LadderCableAssembly%i",i+1);
bf210566 3714 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
3715 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
3716 new TGeoCombiTrans((n-1)
3717 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3718 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
3719 0.,new TGeoRotation("",180,0.,0.)));
3720 laddercableassemblylist->Add(ladderCable[i]);
3721}
3722 return laddercableassemblylist;
3723}
3724///////////////////////////////////////////////////////////////////////////////
3725void AliITSv11GeometrySSD::SetLadderSegment(){
3726 /////////////////////////////////////////////////////////////
3727 // Method Generating Ladder Segment Array
3728 /////////////////////////////////////////////////////////////
3729 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
3730 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
cd2243fb 3731
3732 /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
3733 TGeoXtru *laddersegmentshape = new TGeoXtru(2);
3734 static const Int_t ntrianglevtx = 3;
3735 Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
3736 Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
3737 laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
3738 laddersegmentshape->DefineSection(0,0);
3739 laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth); // MVL
3740 fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
3741 fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
3742 */
3743
bf210566 3744 if(!fCreateMaterials) CreateMaterials();
3745 if(!fTransformationMatrices) CreateTransformationMatrices();
3746 if(!fBasicObjects) CreateBasicObjects();
3747 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
3748 // Placing Carbon Fiber Support
3749 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
3750 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3751 fcarbonfibersupportmatrix[j]);
3752 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3753 fcarbonfibersupportmatrix[j]);
d7599219 3754 }
bf210566 3755 // Placing Carbon Fiber Junction
cd2243fb 3756 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
bf210566 3757 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
3758 fcarbonfiberjunctionmatrix[j]);
cd2243fb 3759 }
bf210566 3760 // Placing Carbon Fiber Lower Support
cd2243fb 3761 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
bf210566 3762 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
3763 fcarbonfiberlowersupportrans[j]);
cd2243fb 3764 }
bf210566 3765 // Placing SSD Sensor Support
3766 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
cd2243fb 3767 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
bf210566 3768 fssdsensorsupport[1][i],
3769 j+1,fssdsensorsupportmatrix[j]);
3770 // Placing SSD Cooling Tube Support
3771 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
3772 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3773 fcoolingtubesupportmatrix[j]);
3774 // Placing SSD Cooling Tube
cd2243fb 3775 fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
3776 fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
bf210566 3777 // Placing SSD Hybrid
3778 switch(i){
3779 case 0:
3780 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
3781 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3782 break;
3783 case 1:
3784 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
3785 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3786 break;
3787 }
3788 // Placing Cooling Block System
cd2243fb 3789 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
bf210566 3790 // Placing SSD Flex
cd2243fb 3791 for(Int_t j=0; j<fgkflexnumber; j++){
3792 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
3793 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
3794 }
bf210566 3795 }
d7599219 3796}
bf210566 3797///////////////////////////////////////////////////////////////////////////////
3798void AliITSv11GeometrySSD::SetEndLadderSegment(){
3799 /////////////////////////////////////////////////////////////
3800 // Method Generating End Ladder
3801 /////////////////////////////////////////////////////////////
3802 // End Ladder Carbon Fiber Junction
3803 /////////////////////////////////////////////////////////////
3804 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
3805 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
3806 if(!fCreateMaterials) CreateMaterials();
3807 if(!fTransformationMatrices) CreateTransformationMatrices();
3808 if(!fBasicObjects) CreateBasicObjects();
3809 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
b28b5356 3810 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
bf210566 3811 fendladdersegment[i]->AddNode(j==2 ?
3812 fendladdercarbonfiberjunction[i][1] :
3813 fendladdercarbonfiberjunction[i][0],
3814 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
3815 }
3816 /////////////////////////////////////////////////////////////
3817 // End Ladder Carbon Fiber Support
3818 /////////////////////////////////////////////////////////////
3819 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
3820 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
3821 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3822 fendladdercarbonfibermatrix[i][j]);
3823 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3824 fendladdercarbonfibermatrix[i][j]);
3825 }
3826 /////////////////////////////////////////////////////////////
3827 // End Ladder Mounting Block
3828 /////////////////////////////////////////////////////////////
9b0c60ab 3829 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3830 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
e21cdd03 3831 fendladdermountingblockcombitrans[i]);
9b0c60ab 3832 /////////////////////////////////////////////////////////////
e5bf64ae 3833 // End Ladder Mounting Block Clip
9b0c60ab 3834 /////////////////////////////////////////////////////////////
3835 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3836 for(Int_t j=0; j<2; j++)
e21cdd03 3837 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
3838 fendladdermountingblockclipmatrix[i][j]);
bf210566 3839 /////////////////////////////////////////////////////////////
3840 // End Ladder Lower Supports
44285dfa 3841 /////////////////////////////////////////////////////////////
bf210566 3842 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
e21cdd03 3843 fendladderlowersupptrans[0]);
bf210566 3844 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
e21cdd03 3845 fendladderlowersupptrans[1]);
bf210566 3846 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
e21cdd03 3847 fendladderlowersupptrans[2]);
9b0c60ab 3848 /////////////////////////////////////////////////////////////
3849 // End Ladder Cooling Tube Support
3850 /////////////////////////////////////////////////////////////
3851 for(Int_t i=0; i<2; i++)
3852 for(Int_t j=0; j<(i==0?4:2); j++)
e21cdd03 3853 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3854 fendladdercoolingtubesupportmatrix[i][j]);
9b0c60ab 3855 /////////////////////////////////////////////////////////////
3856 // End Ladder Cooling Tube Support
3857 /////////////////////////////////////////////////////////////
cd2243fb 3858 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
3859 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
3860 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
3861 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
bf210566 3862}
3863///////////////////////////////////////////////////////////////////////////////
3864void AliITSv11GeometrySSD::SetLadder(){
3865 /////////////////////////////////////////////////////////////
3866 // Method Generating Ladder of Layer 5 and 6
44285dfa 3867 /////////////////////////////////////////////////////////////
bf210566 3868 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
3869 fgkSSDLay6SensorsNumber};
3870 /////////////////////////////////////////////////////////////////////////////
3871 /// Generating Ladder Mother Volume Containing Ladder
3872 /////////////////////////////////////////////////////////////////////////////
15be6f41 3873 /* TGeoXtru* laddershape[fgkladdernumber];
bf210566 3874 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
15be6f41 3875 */
bf210566 3876 const Int_t kmothervertexnumber = 8;
3877 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
3878 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
3879 ///////////////////////
3880 // Setting the vertices
3881 ///////////////////////
3882 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
78e34526 3883 * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]);
bf210566 3884 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
0fb26117 3885 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
bf210566 3886 xmothervertex[0][1] = xmothervertex[0][0];
78e34526 3887 ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010
bf210566 3888 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
3889 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
3890 ymothervertex[0][2] = ymothervertex[0][1];
3891 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
3892 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
3893 xmothervertex[0][4] = -xmothervertex[0][3];
3894 ymothervertex[0][4] = ymothervertex[0][3];
3895 xmothervertex[0][5] = -xmothervertex[0][2];
3896 ymothervertex[0][5] = ymothervertex[0][2];
3897 xmothervertex[0][6] = -xmothervertex[0][1];
3898 ymothervertex[0][6] = ymothervertex[0][1];
3899 xmothervertex[0][7] = -xmothervertex[0][0];
3900 ymothervertex[0][7] = ymothervertex[0][0];
3901 for(Int_t i=0; i<kmothervertexnumber; i++){
3902 xmothervertex[1][i] = xmothervertex[0][i];
3903 ymothervertex[1][i] = ymothervertex[0][i];
3904 }
0fb26117 3905///////////////////////////////////////////////////////////////////////////
3906// Disalignement Mother Volume corrections 25/08/08
3907///////////////////////////////////////////////////////////////////////////
160835d5 3908 TGeoXtru* leftladdershape1[fgkladdernumber];
3909 TGeoXtru* leftladdershape2[fgkladdernumber];
0fb26117 3910 TGeoXtru* centersensorladdershape[fgkladdernumber];
160835d5 3911 TGeoXtru* rightladdershape1[fgkladdernumber];
3912 TGeoXtru* rightladdershape2[fgkladdernumber];
bf210566 3913 for(Int_t i=0; i<fgkladdernumber; i++){
160835d5 3914 leftladdershape1[i] = new TGeoXtru(2);
3915 leftladdershape2[i] = new TGeoXtru(2);
3916 centersensorladdershape[i] = new TGeoXtru(2);
3917 rightladdershape1[i] = new TGeoXtru(2);
3918 rightladdershape2[i] = new TGeoXtru(2);
3919 }
0fb26117 3920 //////////////////////////////////////
160835d5 3921 // Setting the names for shapes
0fb26117 3922 //////////////////////////////////////
160835d5 3923 leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
3924 leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
3925 leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
3926 leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
0fb26117 3927 centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
3928 centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
160835d5 3929 rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
3930 rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
3931 rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
3932 rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
0fb26117 3933 //////////////////////////////////////
160835d5 3934 Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
3935 Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
0fb26117 3936 Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
3937 Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
160835d5 3938 Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
3939 Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
3940 for(Int_t i=0; i<fgkladdernumber; i++) {
3941 for(Int_t j=0; j<kmothervertexnumber; j++){
3942 xcentersensorvertex[i][j] = xmothervertex[i][j];
3943 ycentersensorvertex[i][j] = ymothervertex[i][j];
3944 xend1laddervertex[i][j] = xmothervertex[i][j];
3945 yend1laddervertex[i][j] = ymothervertex[i][j];
3946 xend2laddervertex[i][j] = xmothervertex[i][j];
3947 yend2laddervertex[i][j] = ymothervertex[i][j];
3948 }
3949 // Add some space around sensors to accommodate misalignments
3950 xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
3951 xcentersensorvertex[i][1] = xcentersensorvertex[0][0];
3952 xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
3953 xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
3954
3955 ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
3956 ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
3957
3958 // Center Ladder Piece
3959 centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
3960 ycentersensorvertex[i]);
3961 centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3962 + 1.45*fgkSSDMountingBlockWidth);
3963 centersensorladdershape[i]->DefineSection(1, ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
3964 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
3965 - 2.4*fgkSSDMountingBlockWidth);
0fb26117 3966
160835d5 3967 // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
0fb26117 3968
160835d5 3969 // Cuts off first corner (neg x)
3970 xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
3971 xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
3972 // Cuts off last part (pos x)
3973 xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
3974 xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
0fb26117 3975
160835d5 3976 leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3977 yend1laddervertex[i]);
3978 leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
3979 leftladdershape1[i]->DefineSection(1, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3980 - fgkEndLadderMountingBlockPosition[0]);
3981
3982 leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3983 yend2laddervertex[i]);
3984 leftladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3985 - fgkEndLadderMountingBlockPosition[0]);
3986 leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
3987 + 1.45*fgkSSDMountingBlockWidth); // connect to main volume at -1.6725 cm
3988
3989 rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3990 yend1laddervertex[i]);
3991 rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
3992 +fgkEndLadderCarbonFiberLowerJunctionLength[0]
3993 -2.4*fgkSSDMountingBlockWidth);
3994 rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
3995 + fgkEndLadderMountingBlockPosition[1]);
3996
3997 rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3998 yend2laddervertex[i]);
3999 rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4000 + fgkEndLadderMountingBlockPosition[1]);
4001 rightladdershape2[i]->DefineSection(1, ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4002 + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4003 }
4004 TGeoCompositeShape* laddershapecontainer[2];
4005 laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4006 "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4007 "+Lay5CenterSensorContainer"
4008 "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4009 laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4010 "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4011 "+Lay6CenterSensorContainer"
4012 "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4013 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4014 for(Int_t i=0; i<fgkladdernumber; i++){
4015 fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4016 fladder[i]->SetLineColor(4);
4017 }
bf210566 4018///////////////////////////////////////////////////////////////////////////
4019 if(!fCreateMaterials) CreateMaterials();
4020 if(!fTransformationMatrices) CreateTransformationMatrices();
4021 if(!fBasicObjects) CreateBasicObjects();
4022 SetLadderSegment();
4023 SetEndLadderSegment();
4024 for(Int_t i=0; i<fgkladdernumber; i++){
4025 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4026 //////////////////////////
4027 /// Placing Ladder Segment
4028 //////////////////////////
4029 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4030 fladdersegment[i==0 ? 1 : 0],
4031 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4032 //////////////////////////
4033 /// Placing SSD Sensor
4034 //////////////////////////
ca86fdb4 4035 if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
bf210566 4036 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4037 fssdsensormatrix[i][j]);
4038 }
4039 ///////////////////////////////
4040 /// Placing End Ladder Segment
4041 ///////////////////////////////
160835d5 4042 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
bf210566 4043 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4044 }
d7599219 4045/////////////////////////////////////////////////////////////////////////////
4046/// Placing Ladder Cables
4047/////////////////////////////////////////////////////////////////////////////
bf210566 4048 Int_t sidecablenumber[2][2];
4049 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4050 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4051 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4052 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4053 Double_t carbonfibertomoduleposition[3];
4054 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4055 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4056 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4057 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4058 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4059 - fgkSSDSensorCenterSupportThickness[0]);
4060 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4061 + 0.5*fgkCoolingTubeSupportHeight
4062 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4063 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4064 Double_t ssdendladdercablelength[4];
4065 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4066 + fgkSSDSensorLength
4067 - fgkSSDModuleStiffenerPosition[1]
4068 - fgkSSDStiffenerWidth
4069 - fgkSSDFlexWidth[0]
bf210566 4070 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4071 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4072 + fgkSSDModuleStiffenerPosition[1]
4073 + fgkSSDStiffenerWidth
bf210566 4074 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4075 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4076 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4077 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4078 - kendladdercablecorrection;
44285dfa 4079 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4080 + carbonfibertomoduleposition[1]
d7599219 4081 - fgkSSDModuleStiffenerPosition[1]
4082 - fgkSSDStiffenerWidth)
bf210566 4083 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
78e34526 4084
44285dfa 4085 TList* laddercableassemblylist[4];
4086 const Int_t kendladdercablesnumber = 4;
cd2243fb 4087 TGeoRotation *laddercablerot = new TGeoRotation();
4088 laddercablerot->SetAngles(90.,60.,-90.);
bf210566 4089 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4090 for(Int_t j=0; j<kendladdercablesnumber; j++){
4091 laddercableassemblylist[j] =
4092 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4093 ssdendladdercablelength[j]);
0fb26117 4094 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4095 j<2?1:2,fladdercablematrix[i][j]);
bf210566 4096 }
bf210566 4097}
15be6f41 4098
bf210566 4099////////////////////////////////////////////////////////////////////////////////
4100void AliITSv11GeometrySSD::SetLayer(){
d7599219 4101////////////////////////////////////////////////////////////////////////////////
bf210566 4102 // Creating Ladder of Layer 5 and Layer 6
4103 /////////////////////////////////////////////////////////////
4104 if(!fCreateMaterials) CreateMaterials();
4105 if(!fTransformationMatrices) CreateTransformationMatrices();
4106 if(!fBasicObjects) CreateBasicObjects();
4107 SetLadder(); // Generating the ladder of Layer5 and Layer6
4108 const Int_t kssdlayladdernumber[fgklayernumber] =
4109 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4110 /////////////////////////////////////////////////////////////
4111 // Generating mother volumes for Layer5 and Layer6
4112 /////////////////////////////////////////////////////////////
e5bf64ae 4113 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4114 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
bf210566 4115 Int_t *ladderindex[fgklayernumber];
4116 Int_t index[fgklayernumber] = {8,9};
4117 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4118 for(Int_t i=0; i<fgklayernumber; i++)
4119 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4120 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4121 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4122 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4123 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4124 }
44285dfa 4125 /////////////////////////////////////////////////////////////
bf210566 4126 // Deallocating memory
4127 /////////////////////////////////////////////////////////////
7b208ef4 4128 for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
d7599219 4129}
4130////////////////////////////////////////////////////////////////////////////////
4131void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4132 /////////////////////////////////////////////////////////////
4133 // Insert the layer 5 in the mother volume.
4134 /////////////////////////////////////////////////////////////
4135 if (! moth) {
160835d5 4136 AliError("Can't insert layer5, mother is null!\n");
44285dfa 4137 return;
4138 };
bf210566 4139 if(!fSSDLayer5) SetLayer();
4140 fMotherVol = moth;
4141 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4142 + fgkLay5CenterITSPosition);
4143 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4144 }
d7599219 4145////////////////////////////////////////////////////////////////////////////////
4146void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4147 /////////////////////////////////////////////////////////////
4148 // Insert the layer 6 in the mother volume.
4149 /////////////////////////////////////////////////////////////
4150 if (! moth) {
160835d5 4151 AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
44285dfa 4152 return;
4153 };
bf210566 4154 if(!fSSDLayer6) SetLayer();
4155 fMotherVol = moth;
4156 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4157 + fgkLay6CenterITSPosition);
4158 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4159 }
bf210566 4160 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4161 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4162 /////////////////////////////////////////////////////////////
4163 // Method generating the Arc structure of Ladder Support
4164 /////////////////////////////////////////////////////////////
4165 const Int_t kssdlayladdernumber[fgklayernumber] =
4166 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4167 Double_t mountingsupportedge[fgklayernumber];
4168 Double_t mountingblockratio[fgklayernumber];
4169 Double_t theta[fgklayernumber];
4170 Double_t phi[fgklayernumber];
4171 Double_t psi0[fgklayernumber];
4172 Double_t deltapsi[fgklayernumber];
4173 TVector3* mountingsupportedgevector[fgklayernumber];
4174 for(Int_t i=0; i<fgklayernumber; i++){
4175 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4176 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4177 * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4178 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4179 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4180 / kssdlayladdernumber[i])));
4181 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4182 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4183 mountingsupportedgevector[i] = new TVector3();
60e55aee 4184 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4185 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4186 (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4187 (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
9b0c60ab 4188 psi0[i] = 0.5*TMath::Pi()-phi[i];
4189 deltapsi[i] = (theta[i]+phi[i])/nedges;
4190 }
4191 TVector3** vertex[fgklayernumber];
4192 TList* vertexlist[fgklayernumber];
4193 Int_t indexedge[fgklayernumber] = {0,0};
4194 for(Int_t i=0; i<fgklayernumber; i++){
4195 vertex[i] = new TVector3*[nedges+1];
4196 vertexlist[i] = new TList();
4197 }
4198 for(Int_t i=0; i<fgklayernumber; i++){
4199 for(Int_t j=0; j<nedges+1; j++){
4200 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
c2aad3ae 4201 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]), 0);
9b0c60ab 4202 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4203 vertexlist[i]->Add(vertex[i][j]);
4204 }
4205 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4206 }
4207 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4208 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4209 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4210 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4211 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4212 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4213 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4214 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4215 for(Int_t i=0; i<fgklayernumber; i++){
4216 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4217 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4218 xcentervertex[i] = new Double_t[indexedge[i]+3];
4219 ycentervertex[i] = new Double_t[indexedge[i]+3];
4220 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4221 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4222 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4223 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4224 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4225 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4226 ((TVector3*)vertexlist[i]->At(j))->X();
4227 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4228 ((TVector3*)vertexlist[i]->At(j))->Y();
4229 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4230 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4231 if(j<indexedge[i]+1){
4232 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4233 ((TVector3*)vertexlist[i]->At(j))->X();
4234 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4235 ((TVector3*)vertexlist[i]->At(j))->Y();
4236 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4237 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4238 }
4239 }
4240 xsidevertex[i][1] = xsidevertex[i][0];
4241 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4242 xsidevertex[i][2] = xsidevertex[i][3];
4243 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4244 xcentervertex[i][1] = xcentervertex[i][0];
4245 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4246 xcentervertex[i][2] = xcentervertex[i][3];
4247 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4248 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4249 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4250 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4251 ycenterlowervertex[i][0] = ysidevertex[i][0];
4252 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4253 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4254 }
4255 /////////////////////////////////////////////////////////////
4256 // Building the Arc Structure of Ladder Supports
4257 /////////////////////////////////////////////////////////////
4258 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4259 TGeoXtru* centermountingsupportshape[fgklayernumber];
4260 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4261 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4262 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4263 TGeoVolume* centermountingblocksupport[fgklayernumber];
4264 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4265 TGeoVolume* centerladdersupportpiece[fgklayernumber];
a3f8715e 4266 char sidemountingblockname[100];
4267 char centermountingblockname[100];
4268 char sideladdersupportpiecename[100];
4269 char centerladdersupportpiecename[100];
9b0c60ab 4270 for(Int_t i=0; i<fgklayernumber; i++){
045be90c 4271 snprintf(sidemountingblockname,100,"MountingBlockSupportSideLay%dArc",i+5);
4272 snprintf(centermountingblockname,100,"MountingBlockSupportCenterLay%dArc",i+5);
4273 snprintf(sideladdersupportpiecename,100,"SideLadderSupportPieceLay%d",i+5);
4274 snprintf(centerladdersupportpiecename,100,"CenterLadderSupportPieceLay%d",i+5);
4275 sidemountingblocksupportshape[i] = new TGeoXtru(2);
9b0c60ab 4276 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4277 xsidevertex[i],ysidevertex[i]);
4278 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4279 -fgkMountingBlockSupportWidth[0]);
4280 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4281 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4282 sidemountingblocksupportshape[i],
4283 fSSDAlCoolBlockMedium);
4284 sidemountingblocksupport[i]->SetLineColor(9);
4285 centermountingsupportshape[i] = new TGeoXtru(2);
4286 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4287 xcentervertex[i],ycentervertex[i]);
4288 centermountingsupportshape[i]->DefineSection(0,0.);
4289 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4290 -fgkMountingBlockSupportWidth[0]);
160835d5 4291
9b0c60ab 4292 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4293 centermountingsupportshape[i],
4294 fSSDAlCoolBlockMedium);
4295 centermountingblocksupport[i]->SetLineColor(9);
4296 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4297 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4298 xsidelowervertex[i],ysidelowervertex[i]);
4299 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4300 -fgkMountingBlockSupportWidth[0]);
4301 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4302 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4303 sideladdersupportpieceshape[i],
e21cdd03 4304 fSSDCarbonFiberMedium);
9b0c60ab 4305 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4306 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4307 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4308 xcenterlowervertex[i],ycenterlowervertex[i]);
4309 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4310 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4311 -fgkMountingBlockSupportWidth[0]);
4312 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4313 centerladdersupportpieceshape[i],
e21cdd03 4314 fSSDCarbonFiberMedium);
9b0c60ab 4315 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4316 }
4317 /////////////////////////////////////////////////////////////
4318 // Building the Up Structure of Ladder Supports
4319 /////////////////////////////////////////////////////////////
4320 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4321 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4322 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4323 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4324 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4325 //////////////////////////////////////////////////////////
4326 // Setting the volume for TGeoXtru Mounting Block Piece
4327 //////////////////////////////////////////////////////////
4328 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4329 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4330 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4331 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4332 TGeoVolume* mountingblockpieceup[fgklayernumber];
4333 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4334 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4335 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4336 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
a3f8715e 4337 char mountingblockpiecedownname[100];
4338 char mountingblockpieceupname[100];
9b0c60ab 4339 for(Int_t i=0; i<fgklayernumber; i++){
4340 ///////////////////////////
4341 // Mounting Block Down Vertex
4342 ///////////////////////////
4343 mountingblockpiecedownshape[i] = new TGeoXtru(2);
045be90c 4344 snprintf(mountingblockpiecedownname,100,"MountingBlockPieceDownLay%d",i+5);
9b0c60ab 4345 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4346 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4347 + fgkMountingBlockSupportDownHeight
4348 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4349 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4350 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4351 + fgkSSDMountingBlockHeight[1]
4352 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4353 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4354 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4355 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4356 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4357 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4358 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4359 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4360 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4361 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4362 + fgkSSDMountingBlockHeight[2]
4363 - fgkSSDMountingBlockHeight[0];
4364 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4365 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4366 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4367 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4368 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4369 mountingblockpiecedownyvertex[i]);
4370 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4371 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4372 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
e21cdd03 4373 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
9b0c60ab 4374 mountingblockpiecedown[i]->SetLineColor(fColorG10);
160835d5 4375
9b0c60ab 4376 ///////////////////////////
4377 // Mounting Block Up Vertex
4378 ///////////////////////////
4379 mountingblockpieceupshape[i] = new TGeoXtru(2);
045be90c 4380 snprintf(mountingblockpieceupname,100,"MountingBlockPieceUpLay%d",i+5);
9b0c60ab 4381 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4382 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4383 + fgkMountingBlockSupportUpHeight[i]
4384 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4385 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4386 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4387 + fgkSSDMountingBlockHeight[1]
4388 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4389 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4390 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4391 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4392 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4393 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4394 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4395 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4396 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4397 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4398 + fgkSSDMountingBlockHeight[2]
4399 - fgkSSDMountingBlockHeight[0];
4400 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4401 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4402 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4403 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
160835d5 4404
9b0c60ab 4405 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4406 mountingblockpieceupyvertex[i]);
4407 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4408 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4409 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
e21cdd03 4410 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
9b0c60ab 4411 mountingblockpieceup[i]->SetLineColor(fColorG10);
4412 }
4413 ///////////////////////////////////////////////////////////////////
4414 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4415 ///////////////////////////////////////////////////////////////////
4416 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4417 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4418 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4419 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4420 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4421 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4422 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4423 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
a3f8715e 4424 char mountingblocksupportrapezoidowname[100];
4425 char mountingblocksupportrapezoidupname[100];
9b0c60ab 4426 Double_t scalefactor = 3./4.;
4427 for(Int_t i=0; i<fgklayernumber; i++){
4428 ////////////////////////////////////////////
4429 // Mounting Block Support Down Trapezoid Vertex
4430 ////////////////////////////////////////////
4431 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4432 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4433 - mountingsupportedge[i];
4434 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4435 mountingblocksupportrapezoidownxvertex[i][1] =
4436 mountingblocksupportrapezoidownxvertex[i][0];
4437 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4438 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4439 - mountingblockpiecedownyvertex[i][0]);
4440 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4441 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4442 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4443 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4444 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4445 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
160835d5 4446
9b0c60ab 4447 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4448 mountingblocksupportrapezoidownyvertex[i]);
4449 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4450 -fgkMountingBlockSupportWidth[0]);
4451 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
045be90c 4452 snprintf(mountingblocksupportrapezoidowname,100,"MountingBlockSuppTrapezoidDownLay%d",i+5);
9b0c60ab 4453 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
e21cdd03 4454 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4455 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4456 ////////////////////////////////////////////
4457 // Mounting Block Support Up Trapezoid Vertex
4458 ////////////////////////////////////////////
4459 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4460 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4461 - mountingsupportedge[i];
4462 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4463 mountingblocksupportrapezoidupxvertex[i][1] =
4464 mountingblocksupportrapezoidupxvertex[i][0];
4465 mountingblocksupportrapezoidupyvertex[i][1] =
4466 mountingblockpieceupyvertex[i][0]
4467 + scalefactor*(mountingblockpieceupyvertex[i][1]
4468 - mountingblockpieceupyvertex[i][0]);
4469 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4470 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4471 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4472 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4473 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4474 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
160835d5 4475
9b0c60ab 4476 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4477 mountingblocksupportrapezoidupyvertex[i]);
4478 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4479 -fgkMountingBlockSupportWidth[0]);
4480 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
045be90c 4481 snprintf(mountingblocksupportrapezoidupname,100,"MountingBlockSuppTrapezoidUpLay%d",i+5);
9b0c60ab 4482 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
e21cdd03 4483 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4484 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4485 }
4486 ///////////////////////////////////////////////////////////////////
4487 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4488 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4489 Double_t boxoriginup[fgklayernumber][2][3];
4490 Double_t boxorigindown[fgklayernumber][2][3];
a3f8715e 4491 char mountingblocksupportboxdownname[100];
4492 char mountingblocksupportboxupname[100];
9b0c60ab 4493 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4494 mountingblocksupportrot->SetAngles(90.,180.,-90);
4495 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4496 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4497 TGeoHMatrix* laddersupportmatrix[2];
4498 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4499 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4500 /////////////////////////////////////////////////////////////
4501 // Creating Mother Volume for Containment
4502 /////////////////////////////////////////////////////////////
4503 Double_t *xmothervertex[fgklayernumber];
4504 Double_t *ymothervertex[fgklayernumber];
4505 for(Int_t i=0; i<fgklayernumber; i++){
4506 xmothervertex[i] = new Double_t[8];
4507 ymothervertex[i] = new Double_t[8];
4508 }
4509 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4510 TGeoVolume* downmotherladdersupport[fgklayernumber];
4511 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
160835d5 4512 TGeoVolume* upmotherladdersupport[fgklayernumber];
a3f8715e 4513 char upmotheladdersupportname[100];
4514 char downmotheladdersupportname[100];
9b0c60ab 4515 for(Int_t i=0; i<fgklayernumber; i++){
4516 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4517 - mountingsupportedge[i];
4518 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4519 xmothervertex[i][1] = xmothervertex[i][0];
4520 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4521 + fgkMountingBlockSupportWidth[0];
4522 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4523 ymothervertex[i][2] = ymothervertex[i][1];
4524 xmothervertex[i][3] = xmothervertex[i][2];
4525 ymothervertex[i][3] = -ymothervertex[i][0];
4526 xmothervertex[i][4] = -xmothervertex[i][0];
4527 ymothervertex[i][4] = ymothervertex[i][3];
4528 xmothervertex[i][5] = xmothervertex[i][4];
4529 ymothervertex[i][5] = -ymothervertex[i][1];
4530 xmothervertex[i][6] = -xmothervertex[i][2];
4531 ymothervertex[i][6] = ymothervertex[i][5];
4532 xmothervertex[i][7] = xmothervertex[i][6];
4533 ymothervertex[i][7] = ymothervertex[i][0];
160835d5 4534
045be90c 4535 snprintf(downmotheladdersupportname,100,"LadderSupportDownLay%d",i+5);
4536 snprintf(upmotheladdersupportname,100,"LadderSupportUpLay%d",i+5);
160835d5 4537
4538 downmotherladdersupportshape[i] = new TGeoXtru(2);
9b0c60ab 4539 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4540 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
160835d5 4541 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
9b0c60ab 4542 + fgkMountingBlockSupportDownHeight
4543 + fgkSSDMountingBlockHeight[1]
4544 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4545 - fgkSSDModuleCoolingBlockToSensor
4546 - fgkSSDLadderVerticalDisalignment);
4547
4548// - fgkSSDModuleVerticalDisalignment);
4549 //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4550
4551 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4552 downmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4553 upmotherladdersupportshape[i] = new TGeoXtru(2);
4554 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4555 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4556 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4557 + fgkMountingBlockSupportUpHeight[i]
4558 + fgkSSDMountingBlockHeight[1]
4559 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4560 - fgkSSDModuleCoolingBlockToSensor
4561 - fgkSSDLadderVerticalDisalignment);
4562
4563 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4564 upmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4565 }
4566 for(Int_t i=0; i<fgklayernumber; i++){
4567 /////////////////////////
4568 // Setting the box origin
4569 /////////////////////////
4570 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4571 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4572 + 0.5*fgkMountingBlockSupportDownHeight
4573 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4574 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4575 - 0.5*fgkMountingBlockSupportWidth[0];
4576
4577 boxorigindown[i][1][0] = 0.0;
4578 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4579 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4580 - fgkMountingBlockSupportWidth[0]);
4581
4582 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4583 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4584 + 0.5*fgkMountingBlockSupportUpHeight[i]
4585 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4586 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4587 - 0.5*fgkMountingBlockSupportWidth[0];
4588
4589 boxoriginup[i][1][0] = 0.0;
160835d5 4590 boxoriginup[i][1][1] = boxoriginup[i][0][1];
9b0c60ab 4591 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4592 - fgkMountingBlockSupportWidth[0]);
4593
4594 /////////////////////////
4595 // Setting the boxes
4596 /////////////////////////
4597 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4598 + fgkSSDMountingBlockLength[0]),
160835d5 4599 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4600 0.5*fgkMountingBlockSupportWidth[0],
4601 boxorigindown[i][0]);
160835d5 4602 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4603 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4604 0.5*(fgkMountingBlockSupportWidth[1]
4605 - fgkMountingBlockSupportWidth[0]),
4606 boxorigindown[i][1]);
4607
4608 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4609 + fgkSSDMountingBlockLength[0]),
160835d5 4610 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4611 0.5*fgkMountingBlockSupportWidth[0],
4612 boxoriginup[i][0]);
160835d5 4613
9b0c60ab 4614 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
160835d5 4615 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4616 0.5*(fgkMountingBlockSupportWidth[1]
4617 - fgkMountingBlockSupportWidth[0]),
4618 boxoriginup[i][1]);
4619 ///////////////////////////////////////
160835d5 4620 // Adding the Volumes to Mother Volume
9b0c60ab 4621 ///////////////////////////////////////
4622 for(Int_t j=0; j<2; j++){
045be90c 4623 snprintf(mountingblocksupportboxdownname,100,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4624 snprintf(mountingblocksupportboxupname,100,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4625 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4626 mountingblocksupportboxdownshape[i][j],
4627 fSSDCarbonFiberMedium);
4628 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4629 mountingblocksupportboxupshape[i][j],
4630 fSSDCarbonFiberMedium);
9b0c60ab 4631 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4632 mountingblocksupportboxup[i][j]->SetLineColor(9);
4633 for(Int_t k=0; k<2; k++){
4634 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
160835d5 4635 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
9b0c60ab 4636 }
4637 }
4638 for(Int_t k=0; k<2; k++){
4639 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4640 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4641 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4642 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
160835d5 4643 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4644 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4645 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
160835d5 4646 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4647 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4648 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4649 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4650 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4651 }
4652 }
4653 TList* laddersupportlist = new TList();
4654 laddersupportlist->Add(downmotherladdersupport[0]);
4655 laddersupportlist->Add(upmotherladdersupport[0]);
4656 laddersupportlist->Add(downmotherladdersupport[1]);
4657 laddersupportlist->Add(upmotherladdersupport[1]);
4658 /////////////////////////////////////////////////////////////
4659 // Deallocating memory
4660 /////////////////////////////////////////////////////////////
4661 for(Int_t i=0; i<fgklayernumber; i++){
4662 for(Int_t j=0; j<nedges+1; j++)
4663 delete vertex[i][j];
4664 delete mountingsupportedgevector[i];
4665 delete [] vertex[i];
4666 delete vertexlist[i];
4667 delete [] xsidevertex[i];
4668 delete [] ysidevertex[i];
4669 delete [] xcentervertex[i];
4670 delete [] ycentervertex[i];
4671 delete [] xsidelowervertex[i];
4672 delete [] ysidelowervertex[i];
4673 delete [] xcenterlowervertex[i];
4674 delete [] ycenterlowervertex[i];
7b208ef4 4675 delete [] xmothervertex[i];
4676 delete [] ymothervertex[i];
9b0c60ab 4677 }
3e008bd7 4678 delete [] xsidevertex;
4679 delete [] ysidevertex;
4680 delete [] xcentervertex;
4681 delete [] ycentervertex;
4682 delete [] xsidelowervertex;
4683 delete [] ysidelowervertex;
4684 delete [] xcenterlowervertex;
4685 delete [] ycenterlowervertex;
9b0c60ab 4686 delete globalrefladdersupportrot;
4687 delete mountingblocksupportrot;
4688 /////////////////////
4689 return laddersupportlist;
4690}
4691 ////////////////////////////////////////////////////////////////////////////////
4692void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4693//////////////////////////////////////////
4694// Method Generating Ladder Support Ring
4695//////////////////////////////////////////
4696 if(!fCreateMaterials) CreateMaterials();
4697 if(!fTransformationMatrices) CreateTransformationMatrices();
4698 if(!fBasicObjects) CreateBasicObjects();
4699 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4700 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4701 const Int_t kssdlayladdernumber[fgklayernumber] =
4702 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4703 Double_t mountingsupportedge[fgklayernumber];
4704 Double_t mountingblockratio[fgklayernumber];
4705 Double_t theta[fgklayernumber];
4706 Double_t phi[fgklayernumber];
4707 for(Int_t i=0; i<fgklayernumber; i++){
4708 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4709 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4710 *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4711 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4712 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4713 / kssdlayladdernumber[i])));
4714 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4715 / fgkMountingBlockSupportRadius[i]);
4716 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4717 }
4718 TGeoRotation* globalrot = new TGeoRotation();
4719 globalrot->SetAngles(0.,-90.,0.);
4720 TGeoRotation** laddersupportrot[fgklayernumber];
4721 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4722 for(Int_t i=0; i<fgklayernumber; i++){
4723 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4724 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4725 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4726 laddersupportrot[i][j] = new TGeoRotation();
4727 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4728 switch(i){
4729 case 0: //Ladder of Layer5
4730 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4731 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4732 laddersupportmatrix[i][j]);
4733 break;
4734 case 1: //Ladder of Layer6
4735 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4736 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4737 laddersupportmatrix[i][j]);
4738 break;
4739 }
4740 }
4741 }
4742 /////////////////////////////////////////////////////////////
4743 // Creating Lower Ladder Support
4744 /////////////////////////////////////////////////////////////
4745 TVector3** ringsupportvertex[fgklayernumber];
4746 Double_t angle = 360./nedges;
4747 for(Int_t i=0; i<fgklayernumber; i++){
4748 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4749 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
c2aad3ae 4750 * TMath::Cos(theta[i]), 0);
9b0c60ab 4751 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4752 - mountingsupportedge[i],
c2aad3ae 4753 ringsupportvertex[i][0]->Y(), 0);
9b0c60ab 4754 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
c2aad3ae 4755 ringsupportvertex[i][1]->Y(),0);
9b0c60ab 4756 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4757 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4758 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4759 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4760 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4761 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4762 }
4763 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4764 for(Int_t j=0; j<nedges+1; j++){
4765 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
cd2243fb 4766 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
c2aad3ae 4767 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle), 0);
9b0c60ab 4768 }
4769 }
4770 Double_t **xmothervertex = new Double_t*[fgklayernumber];
4771 Double_t **ymothervertex = new Double_t*[fgklayernumber];
4772 for(Int_t i=0; i<fgklayernumber; i++){
4773 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4774 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4775 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4776 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4777 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4778 }
4779 }
0e8760e5 4780////////////////////////////////////////////////////////////////////////////////
4781// Start Corrections 13/06/08
4782////////////////////////////////////////////////////////////////////////////////
a3f8715e 4783 char lowerladderpconsupportname[100];
0e8760e5 4784 TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4785 TGeoVolume* lowerladderpconsupport[fgklayernumber];
4786 Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4787 Double_t lowerladderpconradiusmax[fgklayernumber];
4788 Double_t lowerladderpconradiusmin[fgklayernumber];
4789 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4790 lowerladdersupportrot->SetAngles(90.,180.,-90);
4791 for(Int_t i=0; i<fgklayernumber; i++){
4792 lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4793 * TMath::Cos(theta[i]);
cd2243fb 4794 lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
0e8760e5 4795 }
4796 for(Int_t i=0; i<fgklayernumber; i++){
4797/////////////////////////// Modified Version ?///////////////////
4798 lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4799 for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
4800 lowerladderpconezsection[j],lowerladderpconradiusmin[i],
4801 lowerladderpconradiusmax[i]);
045be90c 4802 snprintf(lowerladderpconsupportname,100,"LowerLadderPConSupportNameLay%d",i+5);
0e8760e5 4803 lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
4804 lowerladderpconsupport[i]->SetLineColor(fColorAl);
4805 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
4806 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
4807 }
4808////////////////////////////////////////////////////////////////////////////////
4809// End Corrections 13/06/08
4810////////////////////////////////////////////////////////////////////////////////
4811 /*char lowerladdersupportname[30];
9b0c60ab 4812 TGeoXtru* lowerladdersupportshape[fgklayernumber];
4813 TGeoVolume* lowerladdersupport[fgklayernumber];
4814 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4815 lowerladdersupportrot->SetAngles(90.,180.,-90);
4816 for(Int_t i=0; i<fgklayernumber; i++){
4817 lowerladdersupportshape[i] = new TGeoXtru(2);
4818 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
4819 xmothervertex[i],ymothervertex[i]);
4820 lowerladdersupportshape[i]->DefineSection(0,0.);
4821 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4822 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
4823 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
4824 lowerladdersupportshape[i],fSSDSupportRingAl);
4825 lowerladdersupport[i]->SetLineColor(fColorAl);
4826 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
4827 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
0e8760e5 4828 }*/
9b0c60ab 4829 /////////////////////////////////////////////////////////////
4830 // Deallocating memory
4831 /////////////////////////////////////////////////////////////
4832 for(Int_t i=0; i<fgklayernumber; i++){
4833 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
4834 delete ringsupportvertex[i][j];
4835 delete [] ringsupportvertex[i];
4836 }
4837 for(Int_t i=0; i<fgklayernumber; i++){
4838 delete [] xmothervertex[i];
4839 delete [] ymothervertex[i];
4840 }
7b208ef4 4841 delete [] xmothervertex;
4842 delete [] ymothervertex;
9b0c60ab 4843 delete globalrot;
4844 for(Int_t i=0; i<fgklayernumber; i++){
4845 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
4846 delete laddersupportrot[i][j];
4847 delete [] laddersupportrot[i];
4848 }
4849 }
4850 ////////////////////////////////////////////////////////////////////////////////
4851 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
4852 /////////////////////////////////////////////////////////////
4853 // Method generating Endcap CoverPlate
4854 /////////////////////////////////////////////////////////////
4855 // Holes Definition
4856 ///////////////////
4857 Int_t nendcapcoverplateholedges = 30;
4858 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
4859 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
4860 0.5*fgkEndCapCoverPlateThickness};
851c0ce3 4861 TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
9b0c60ab 4862 nendcapcoverplateholedges,holesection);
4863 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 4864 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4865 endcapcoverplatesmallhole->SetLineColor(6);
851c0ce3 4866 TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
9b0c60ab 4867 nendcapcoverplateholedges,holesection);
4868 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 4869 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4870 endcapcoverplatebighole->SetLineColor(6);
4871 //////////////////////////
4872 // Screw Piece Definition
4873 //////////////////////////
4874 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
4875 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
4876 CosD(0.5*smallscrewangle),
4877 0.5*fgkEndCapCoverPlateThickness);
4878 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
4879 endcapsmallscrewpieceshape,
4880 fSSDCoolingTubePhynox);
4881 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
4882 ///////////////////
4883 // Box Definition
4884 ///////////////////
4885 TGeoBBox* endcapcoverplateboxshape[4];
4886 TGeoVolume* endcapcoverplatebox[4];
4887 Double_t boxorigin[5][3];
4888 boxorigin[0][0] = 0.;
4889 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
4890 boxorigin[0][2] = 0.;
4891
4892 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
4893 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
4894 boxorigin[1][2] = 0.;
4895
4896 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
4897 + fgkEndCapCoverPlateSmallHoleSeparation[1];
4898 boxorigin[2][1] = boxorigin[1][1];
4899 boxorigin[2][2] = 0.;
4900
4901 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
4902 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
4903 boxorigin[3][1] = boxorigin[1][1];
4904 boxorigin[3][2] = 0.;
4905
4906 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4907 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
4908 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
4909 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
4910
4911 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4912 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4913 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4914 + fgkEndCapCoverPlateSmallHoleRadius,
4915 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
4916
4917 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4918 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4919 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4920 + fgkEndCapCoverPlateSmallHoleRadius,
4921 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
4922
4923 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
4924 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4925 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4926 + fgkEndCapCoverPlateSmallHoleRadius,
4927 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
4928
4929 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 4930 fSSDAlCoolBlockMedium);
9b0c60ab 4931 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 4932 fSSDAlCoolBlockMedium);
9b0c60ab 4933 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 4934 fSSDAlCoolBlockMedium);
9b0c60ab 4935 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 4936 fSSDAlCoolBlockMedium);
9b0c60ab 4937 endcapcoverplatebox[0]->SetLineColor(6);
4938 endcapcoverplatebox[1]->SetLineColor(6);
4939 endcapcoverplatebox[2]->SetLineColor(6);
4940 endcapcoverplatebox[3]->SetLineColor(6);
4941 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
4942 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4943 fgkEndCapCoverPlateSmallHoleRadius,
4944 0.5*fgkEndCapCoverPlateThickness,
4945 endcapfillingboxorigin);
4946 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 4947 fSSDAlCoolBlockMedium);
9b0c60ab 4948 endcapfillingbox->SetLineColor(6);
4949 ////////////////////////////
851c0ce3 4950 // Contour shape Definition
9b0c60ab 4951 ////////////////////////////
4952 const Int_t kcontourvertexnumber = 10;
4953 Double_t xcontourvertex[kcontourvertexnumber];
4954 Double_t ycontourvertex[kcontourvertexnumber];
4955 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
4956 xcontourvertex[1] = xcontourvertex[0];
4957 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4958 xcontourvertex[3] = xcontourvertex[2];
4959 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
4960 xcontourvertex[5] = xcontourvertex[4];
4961 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4962 xcontourvertex[7] = xcontourvertex[6];
4963 xcontourvertex[8] = xcontourvertex[4];
4964 xcontourvertex[9] = xcontourvertex[8];
4965 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4966 - (kendcapcoverplatesmallholenumber[1]-1)
4967 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4968 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
4969 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4970 ycontourvertex[2] = ycontourvertex[1];
4971 ycontourvertex[3] = ycontourvertex[0];
4972 ycontourvertex[4] = ycontourvertex[3];
4973 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
4974 ycontourvertex[6] = ycontourvertex[5];
4975 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
4976 * fgkEndCapCoverPlateSmallHoleSeparation[2]
4977 + fgkEndCapCoverPlateSmallHoleRadius;
4978 ycontourvertex[8] = ycontourvertex[7];
4979 ycontourvertex[9] = ycontourvertex[0];
851c0ce3 4980
4981 Double_t xboxin, dxboxin, yboxin, dyboxin;
4982 Double_t xboxout, dxboxout, yboxout, dyboxout;
4983 Double_t coordmin, coordmax;
4984 coordmin = -fgkEndCapCoverPlateLength[0];
4985 coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4986 xboxout = 0.5*(coordmin+coordmax);
4987 dxboxout = 0.5*(coordmax-coordmin);
4988 coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4989 - (kendcapcoverplatesmallholenumber[1]-1)
4990 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4991 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
4992 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4993 yboxout = 0.5*(coordmin+coordmax);
4994 dyboxout = 0.5*(coordmax-coordmin);
4995 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
4996 coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4997 xboxin = 0.5*(coordmin+coordmax);
4998 dxboxin = 0.5*(coordmax-coordmin);
4999 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5000 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5001 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5002 + fgkEndCapCoverPlateSmallHoleRadius;
5003 yboxin = 0.5*(coordmin+coordmax);
5004 dyboxin = 0.5*(coordmax-coordmin);
5005 new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5006 TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5007 xboxout, yboxout, 0.);
5008 trendCapCoverPlateContourboxout->RegisterYourself();
5009 new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5010 TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5011 xboxin, yboxin, 0.);
5012 trendCapCoverPlateContourboxin->RegisterYourself();
5013 TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5014 "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5015
e21cdd03 5016 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5017 fSSDAlCoolBlockMedium);
9b0c60ab 5018 contour->SetLineColor(6);
5019 /////////////////////////////
851c0ce3 5020 // Hole Contour Shape Definition
9b0c60ab 5021 ////////////////////////////
851c0ce3 5022 coordmin = xcontourvertex[0];
5023 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5024 xboxout = 0.5*(coordmin+coordmax);
5025 dxboxout = 0.5*(coordmax-coordmin);
5026 coordmin = ycontourvertex[1];
5027 coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5028 yboxout = 0.5*(coordmin+coordmax);
5029 dyboxout = 0.5*(coordmax-coordmin);
5030 coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5031 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5032 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5033 xboxin = 0.5*(coordmin+coordmax);
5034 dxboxin = 0.5*(coordmax-coordmin);
5035 coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5036 - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5037 coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5038 yboxin = 0.5*(coordmin+coordmax);
5039 dyboxin = 0.5*(coordmax-coordmin);
5040 new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5041 TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5042 xboxout, yboxout, 0.);
5043 trendCapCoverPlateContourboxout1->RegisterYourself();
5044 new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5045 TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5046 xboxin, yboxin, 0.);
5047 trendCapCoverPlateContourboxin1->RegisterYourself();
5048 TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5049 "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5050
5051
5052 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5053 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5054 xboxout = 0.5*(coordmin+coordmax);
5055 dxboxout = 0.5*(coordmax-coordmin);
5056 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5057 - fgkEndCapCoverPlateWidth[0]);
5058 coordmax = ycontourvertex[0];
5059 yboxout = 0.5*(coordmin+coordmax);
5060 dyboxout = 0.5*(coordmax-coordmin);
5061 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5062 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5063 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5064 xboxin = 0.5*(coordmin+coordmax);
5065 dxboxin = 0.5*(coordmax-coordmin);
5066 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5067 - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5068 - fgkEndCapCoverPlateWidth[0]
5069 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5070 coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5071 yboxin = 0.5*(coordmin+coordmax);
5072 dyboxin = 0.5*(coordmax-coordmin);
5073 new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5074 TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5075 xboxout, yboxout, 0.);
5076 trendCapCoverPlateContourboxout2->RegisterYourself();
5077 new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5078 TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5079 xboxin, yboxin, 0.);
5080 trendCapCoverPlateContourboxin2->RegisterYourself();
5081 TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5082 "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5083
5084// const Int_t kholecontourvertexnumber = 10;
5085
9b0c60ab 5086 Double_t xholecontourvertex[2][kcontourvertexnumber];
5087 Double_t yholecontourvertex[2][kcontourvertexnumber];
5088 xholecontourvertex[0][0] = xcontourvertex[0];
5089 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5090 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5091 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5092 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5093 + 0.5*(fgkEndCapCoverPlateLength[2]
5094 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5095 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5096 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5097 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5098 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5099 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5100 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5101
5102 yholecontourvertex[0][0] = ycontourvertex[1];
5103 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5104 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5105 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5106 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5107 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5108 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5109 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5110 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5111 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5112 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5113
5114 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5115 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5116 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5117 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5118 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5119 + 0.5*(fgkEndCapCoverPlateLength[2]
5120 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5121 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5122 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5123 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5124 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5125 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5126 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5127
5128 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5129 - fgkEndCapCoverPlateWidth[0]);
5130 yholecontourvertex[1][1] = ycontourvertex[0];
5131 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5132 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5133 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5134 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5135 - fgkEndCapCoverPlateWidth[0]
5136 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5137 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5138 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5139 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5140 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5141
9b0c60ab 5142 TGeoVolume* holecontour[2];
851c0ce3 5143 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
e21cdd03 5144 fSSDAlCoolBlockMedium);
9b0c60ab 5145 holecontour[0]->SetLineColor(6);
851c0ce3 5146 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
e21cdd03 5147 fSSDAlCoolBlockMedium);
9b0c60ab 5148 holecontour[1]->SetLineColor(6);
5149 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5150 + fgkEndCapCoverPlateLength[2],0.,0.);
5151 TGeoTranslation* bigholetrans[3];
5152 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5153 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5154 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5155 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5156 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5157 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5158 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5159 /////////////////////////////////
5160 // Mother Volume Xtru Definition
5161 /////////////////////////////////
5162 const Int_t kmothervertexnumber = 12;
5163 Double_t xmothervertex[kmothervertexnumber];
5164 Double_t ymothervertex[kmothervertexnumber];
5165 xmothervertex[0] = xcontourvertex[0];
5166 xmothervertex[1] = xmothervertex[0];
5167 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5168 xmothervertex[3] = xmothervertex[2];
5169 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5170 xmothervertex[5] = xmothervertex[4];
5171 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5172 xmothervertex[7] = xmothervertex[6];
5173 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5174 + fgkEndCapCoverPlateLength[2];
5175 xmothervertex[9] = xmothervertex[8];
5176 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5177 xmothervertex[11] = xmothervertex[10];
5178
5179 ymothervertex[0] = ycontourvertex[0];
5180 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5181 ymothervertex[2] = ymothervertex[1];
5182 ymothervertex[3] = ycontourvertex[1];
5183 ymothervertex[4] = ymothervertex[3];
5184 ymothervertex[5] = ymothervertex[1];
5185 ymothervertex[6] = ymothervertex[5];
5186 ymothervertex[7] = ymothervertex[0];
5187 ymothervertex[8] = ymothervertex[7];
5188 ymothervertex[9] = ymothervertex[8]
5189 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5190 ymothervertex[10] = ymothervertex[9];
5191 ymothervertex[11] = ymothervertex[8];
5192 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5193 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5194 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5195 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5196 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5197 ////////////////////////////////////////
5198 // Adding Nodes
5199 ////////////////////////////////////////
5200// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5201 TGeoTranslation*** endcapcoverplatesmallholetrans;
5202 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5203 Double_t transx[4] = {0,
5204 fgkEndCapCoverPlateSmallHoleSeparation[0],
5205 fgkEndCapCoverPlateSmallHoleSeparation[0]
5206 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5207 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5208 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5209 Int_t index = 0;
5210 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5211 endcapcoverplatesmallholetrans[i] =
5212 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5213 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5214 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5215 endcapcoverplatesmallholetrans[i][j] =
5216 new TGeoTranslation(transx[i],
5217 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5218 if(index!=10){
5219 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5220 index,endcapcoverplatesmallholetrans[i][j]);
5221 mothercoverplate->AddNode(endcapsmallscrewpiece,
5222 index,endcapcoverplatesmallholetrans[i][j]);
5223 }
5224 if(j<kendcapcoverplatesmallholenumber[1]-1)
5225 mothercoverplate->AddNode(endcapcoverplatebox[0],
5226 index,endcapcoverplatesmallholetrans[i][j]);
5227 }
5228 }
5229 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5230 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5231 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5232 mothercoverplate->AddNode(endcapfillingbox,1);
5233 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5234 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5235 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5236 mothercoverplate->AddNode(holecontour[0],1);
5237 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5238 mothercoverplate->AddNode(holecontour[1],1);
5239 mothercoverplate->AddNode(contour,1);
045be90c 5240
5241 for (Int_t i = 0; i < kendcapcoverplatesmallholenumber[0]; i++)
5242 delete [] endcapcoverplatesmallholetrans[i];
5243 delete [] endcapcoverplatesmallholetrans;
9b0c60ab 5244 /////////////////////////////////
5245 return mothercoverplate;
5246 }
5247 ////////////////////////////////////////////////////////////////////////////////
5248 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5249 /////////////////////////////////////////////////////////////
5250 // Getting EndCap Cooling Tube
5251 /////////////////////////////////////////////////////////////
5252 TGeoTorus* endcapcoolingtubetorushape[5];
5253 TGeoVolume* endcapcoolingtubetorus[5];
5254 TGeoTube* endcapcoolingtubeshape[4];
5255 TGeoVolume* endcapcoolingtube[4];
a3f8715e 5256 char endcapcoolingtubetorusname[100];
5257 char endcapcoolingtubename[100];
9b0c60ab 5258 TGeoTorus* endcapcoolingwatertubetorushape[5];
5259 TGeoVolume* endcapcoolingwatertubetorus[5];
5260 TGeoTube* endcapcoolingwatertubeshape[4];
5261 TGeoVolume* endcapcoolingwatertube[4];
a3f8715e 5262 char endcapcoolingwatertubetorusname[100];
5263 char endcapcoolingwatertubename[100];
9b0c60ab 5264 for(Int_t i=0; i<5; i++){
045be90c 5265 snprintf(endcapcoolingtubetorusname,100,"EndCapCoolingTubeTorus%d",i+1);
5266 snprintf(endcapcoolingtubename,100,"EndCapCoolingTube%d",i+1);
5267 snprintf(endcapcoolingwatertubetorusname,100,"EndCapCoolingWaterTubeTorus%d",i+1);
5268 snprintf(endcapcoolingwatertubename,100,"EndCapCoolingWaterTube%d",i+1);
5269 if(i==3){
5270 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5271 fgkEndCapCoolingTubeRadiusMin,
5272 fgkEndCapCoolingTubeRadiusMax,
5273 90.0,fgkEndCapCoolingTubeAngle[3]);
5274 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5275 0.,fgkEndCapCoolingTubeRadiusMin,
5276 90.0,fgkEndCapCoolingTubeAngle[3]);
5277 }
5278 else{
5279 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5280 :fgkEndCapCoolingTubeAxialRadius[1],
5281 fgkEndCapCoolingTubeRadiusMin,
5282 fgkEndCapCoolingTubeRadiusMax,
5283 0.,fgkEndCapCoolingTubeAngle[i]);
5284 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5285 :fgkEndCapCoolingTubeAxialRadius[1],
5286 0.,fgkEndCapCoolingTubeRadiusMin,
5287 0.,fgkEndCapCoolingTubeAngle[i]);
9b0c60ab 5288 }
9b0c60ab 5289 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5290 endcapcoolingtubetorushape[i],
5291 fSSDCoolingTubePhynox);
5292 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5293 endcapcoolingwatertubetorushape[i],
5294 fSSDCoolingTubeWater);
5295 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5296 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5297 if(i<4){
5298 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5299 fgkEndCapCoolingTubeRadiusMax,
5300 0.5*fgkEndCapCoolingTubeLength[i]);
5301 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5302 0.5*fgkEndCapCoolingTubeLength[i]);
5303 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5304 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5305 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5306 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5307 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5308 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5309 }
5310 }
5311 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5312 /////////////////////////////////////////
5313 // Transformation for Volume Positioning
5314 /////////////////////////////////////////
5315 TGeoCombiTrans* coolingtubecombitrans[6];
5316 TGeoRotation* coolingtuberot[8];
5317 TGeoTranslation* coolingtubetrans[6];
5318 TGeoHMatrix* coolingtubematrix[4];
5319 TGeoCombiTrans* torustubecombitrans[4];
5320 TGeoRotation* torustuberot[7];
5321 TGeoTranslation* torustubetrans[4];
5322 TGeoHMatrix* torustubematrix[5];
5323 TGeoCombiTrans* coolingwatertubecombitrans[6];
5324 TGeoRotation* coolingwatertuberot[8];
5325 TGeoTranslation* coolingwatertubetrans[6];
5326 TGeoHMatrix* coolingwatertubematrix[4];
5327 TGeoCombiTrans* toruswatertubecombitrans[4];
5328 TGeoRotation* toruswatertuberot[7];
5329 TGeoTranslation* toruswatertubetrans[4];
5330 TGeoHMatrix* toruswatertubematrix[5];
5331 for(Int_t i=0; i<8; i++){
5332 if(i<6){
5333 coolingtubetrans[i] = new TGeoTranslation();
5334 coolingwatertubetrans[i] = new TGeoTranslation();
5335 }
5336 if(i<8){
5337 coolingtuberot[i] = new TGeoRotation();
5338 coolingwatertuberot[i] = new TGeoRotation();
5339 }
5340 if(i<4){
5341 torustubetrans[i] = new TGeoTranslation();
5342 toruswatertubetrans[i] = new TGeoTranslation();
5343 }
5344 if(i<7){
5345 torustuberot[i] = new TGeoRotation();
5346 toruswatertuberot[i] = new TGeoRotation();
5347 }
5348 }
5349 /////////////////////////////////////////
5350 // Transformation for Inox Volume Positioning
5351 /////////////////////////////////////////
5352 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5353 -endcapcoolingtubeshape[0]->GetDz(),0.);
5354 coolingtuberot[0]->SetAngles(0.,90.,0.);
5355 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5356 *coolingtuberot[0]);
5357
5358 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5359 coolingtuberot[1]->SetAngles(0.,90.,0.);
5360 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5361 *coolingtuberot[1]);
5362
5363 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5364 *CosD(fgkEndCapCoolingTubeAngle[0]),
5365 fgkEndCapCoolingTubeAxialRadius[0]
5366 *SinD(fgkEndCapCoolingTubeAngle[0]),
5367 0.);
5368 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5369 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5370 *coolingtuberot[2]);
5371
5372 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5373 * (*coolingtubecombitrans[1]));
5374
5375 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5376 endcapcoolingtubeshape[1]->GetDz());
5377 torustuberot[0]->SetAngles(0.,90.,0.);
5378 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5379
5380 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5381
5382 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5383 -endcapcoolingtubeshape[2]->GetDz(),0.);
5384 coolingtuberot[3]->SetAngles(0.,90.,0.);
5385 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5386 *coolingtuberot[3]);
5387 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5388 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5389 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5390
5391 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5392 endcapcoolingtubeshape[2]->GetDz());
5393 torustuberot[1]->SetAngles(0.,90.,0.);
5394 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5395 torustuberot[2]->SetAngles(180.,0.,0.);
5396 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5397 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5398
5399 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5400 -fgkEndCapCoolingTubeAxialRadius[0]);
5401 torustuberot[3]->SetAngles(0.,90.,0.);
5402 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5403 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5404 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5405 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5406
5407 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5408 fgkEndCapCoolingTubeAxialRadius[0],0.);
5409 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5410 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5411 *coolingtuberot[5]);
5412 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5413 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5414 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5415
5416 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5417 endcapcoolingtubeshape[0]->GetDz());
5418 torustuberot[5]->SetAngles(0.,90.,0.);
5419 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5420 torustuberot[6]->SetAngles(-90.,0.,0.);
5421 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5422 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5423
5424 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5425 endcapcoolingtubeshape[3]->GetDz(),0.);
5426 coolingtuberot[6]->SetAngles(0.,90.,0.);
5427 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5428 *coolingtuberot[6]);
5429 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5430 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5431 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5432 /////////////////////////////////////////
5433 // Transformation for Water Volume Positioning
5434 /////////////////////////////////////////
5435 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5436 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5437 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5438 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5439 *coolingwatertuberot[0]);
5440
5441 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5442 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5443 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5444 *coolingwatertuberot[1]);
5445
5446 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5447 *CosD(fgkEndCapCoolingTubeAngle[0]),
5448 fgkEndCapCoolingTubeAxialRadius[0]
5449 *SinD(fgkEndCapCoolingTubeAngle[0]),
5450 0.);
5451 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5452 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5453 *coolingwatertuberot[2]);
5454
5455 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5456 * (*coolingwatertubecombitrans[1]));
5457
5458 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5459 endcapcoolingwatertubeshape[1]->GetDz());
5460 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5461 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5462 *toruswatertuberot[0]);
5463
5464 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5465 * (*toruswatertubecombitrans[0]));
5466
5467 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5468 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5469 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5470 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5471 *coolingwatertuberot[3]);
5472 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5473 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5474 * (*coolingwatertubecombitrans[3]));
5475 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5476
5477 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5478 endcapcoolingwatertubeshape[2]->GetDz());
5479 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5480 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5481 *toruswatertuberot[1]);
5482 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5483 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5484 * (*toruswatertubecombitrans[1]));
5485 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5486
5487 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5488 -fgkEndCapCoolingTubeAxialRadius[0]);
5489 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5490 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5491 *toruswatertuberot[3]);
5492 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5493 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5494 * (*toruswatertubecombitrans[2]));
5495 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5496
5497 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5498 fgkEndCapCoolingTubeAxialRadius[0],0.);
5499 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5500 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5501 *coolingwatertuberot[5]);
5502 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5503 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5504 * (*coolingwatertubecombitrans[4]));
5505 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5506
5507 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5508 endcapcoolingwatertubeshape[0]->GetDz());
5509 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5510 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5511 *toruswatertuberot[5]);
5512 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5513 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5514 * (*toruswatertubecombitrans[3]));
5515 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5516
5517 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5518 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5519 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5520 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5521 *coolingwatertuberot[6]);
5522 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5523 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5524 * (*coolingwatertubecombitrans[5]));
5525 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5526 /////////////////////////////////////////
5527 // Positioning Volumes
5528 /////////////////////////////////////////
5529 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5530 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5531
5532 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5533 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5534
5535 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5536 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5537
5538 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5539 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5540
5541 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5542 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5543
5544 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5545 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5546
5547 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5548 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5549
5550 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5551 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5552
5553 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5554 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5555
5556 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5557 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5558 /////////////////////////////////////////////////////////////
5559 // Deallocating memory
5560 /////////////////////////////////////////////////////////////
5561 for(Int_t i=0; i<8; i++){
5562 if(i<6){
5563 delete coolingtubetrans[i];
5564 delete coolingwatertubetrans[i];
5565 if(i!=0){
5566 delete coolingtubecombitrans[i];
5567 delete coolingwatertubecombitrans[i];
5568 }
5569 }
5570 if(i<8){
5571 delete coolingtuberot[i];
5572 delete coolingwatertuberot[i];
5573 }
5574 if(i<4){
5575 delete torustubetrans[i];
5576 delete toruswatertubetrans[i];
5577 delete torustubecombitrans[i];
5578 delete toruswatertubecombitrans[i];
5579 }
5580 if(i<7){
5581 delete torustuberot[i];
5582 delete toruswatertuberot[i];
5583 }
5584 }
5585 /////////////////////////////////////////////////////////////
5586 return endcapcoolingtubemother;
5587 }
5588 ////////////////////////////////////////////////////////////////////////////////
5589 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5590 /////////////////////////////////////////////////////////////
5591 // Getting EndCap Cover Side
5592 /////////////////////////////////////////////////////////////
5593 const Int_t kendcapcoverholenumber[2] = {7,5};
5594 const Int_t kvertexnumber = 15;
5595 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5596 xvertex[0] = 0.0;
5597 xvertex[1] = xvertex[0];
5598 xvertex[2] = fgkEndCapSideCoverLength[0];
5599 xvertex[3] = fgkEndCapSideCoverLength[1];
5600 xvertex[4] = xvertex[3];
5601 xvertex[5] = fgkEndCapSideCoverLength[2];
5602 xvertex[6] = xvertex[5];
5603 xvertex[7] = xvertex[2];
5604 xvertex[8] = xvertex[7];
5605 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5606 xvertex[10] = xvertex[9];
5607 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5608 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5609 * fgkEndCapSideCoverLength[4];
5610 xvertex[12] = xvertex[11];
5611 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5612 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5613 * fgkEndCapSideCoverLength[4];
5614 xvertex[14] = xvertex[13];
5615 yvertex[0] = 0.0;
5616 yvertex[1] = fgkEndCapSideCoverWidth[0];
5617 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5618 yvertex[3] = yvertex[2];
5619 yvertex[4] = fgkEndCapSideCoverWidth[1];
5620 yvertex[5] = yvertex[4];
5621 yvertex[6] = yvertex[0];
5622 yvertex[7] = yvertex[6];
5623 yvertex[8] = fgkEndCapSideCoverWidth[6];
5624 yvertex[9] = yvertex[8];
5625 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5626 yvertex[11] = yvertex[10];
5627 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5628 yvertex[13] = yvertex[12];
5629 yvertex[14] = yvertex[6];
851c0ce3 5630 TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5631 endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5632 endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5633 endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5634 endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5635 TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5636 endcapsidecovershapein->SetName("endcapsidecovershapein");
5637 endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5638 endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5639 endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5640
5641
5642 TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
9b0c60ab 5643 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5644 endcapsidecovershape,fSSDCoolingTubePhynox);
5645 endcapsidecover->SetLineColor(fColorPhynox);
5646 ////////////////////////////////////////////
5647 // Defininition of Mother Volume
5648 ////////////////////////////////////////////
5649 const Int_t kmothervertexnumber = 7;
5650 Double_t xmothervertex[kmothervertexnumber];
5651 Double_t ymothervertex[kmothervertexnumber];
5652 for(Int_t i=0; i<kmothervertexnumber; i++){
5653 xmothervertex[i] = xvertex[i];
5654 ymothervertex[i] = yvertex[i];
5655 }
5656 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5657 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5658 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5659 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5660 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5661 endcapsidecovermothershape,fSSDAir);
5662 ////////////////////////////////////////////
5663 endcapsidecovermother->AddNode(endcapsidecover,1);
5664 TGeoBBox* endcapsidecoverboxshape[4];
5665 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5666 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5667 0.5*fgkEndCapSideCoverLength[4],
5668 0.5*fgkEndCapSideCoverThickness);
5669 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5670 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5671 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5672 - fgkEndCapSideCoverLength[4]),
5673 0.5*fgkEndCapSideCoverThickness);
5674 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5675 0.5*fgkEndCapSideCoverLength[4],
5676 0.5*fgkEndCapSideCoverThickness);
5677 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5678 0.5*fgkEndCapSideCoverWidth[5],
5679 0.5*fgkEndCapSideCoverThickness);
5680 TGeoVolume* endcapsidecoverbox[4];
5681 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5682 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5683 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5684 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5685 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5686// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5687 TGeoTranslation** endcapsidecoverboxtrans;
5688 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5689 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5690 + fgkEndCapSideCoverLength[0],
5691 endcapsidecoverboxshape[0]->GetDY()
5692 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5693 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5694 + xvertex[11],
5695 endcapsidecoverboxshape[1]->GetDY()
5696 + yvertex[12],0.);
5697 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5698 + xvertex[11],
5699 endcapsidecoverboxshape[2]->GetDY()
5700 + yvertex[12]
5701 + 2.*endcapsidecoverboxshape[1]->GetDY()
5702 + fgkEndCapSideCoverWidth[5],0.);
5703 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5704 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5705 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5706 for(Int_t i=0; i<2; i++)
5707 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5708 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5709 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5710 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5711 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5712 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5713 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5714 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5715 }
5716 for(Int_t i=0; i<2; i++)
5717 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5718 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5719 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5720 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5721 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5722 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5723 +fgkEndCapSideCoverLength[4]),0.0);
5724 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5725 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5726 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5727 +i*(kendcapcoverholenumber[1]-1)+j]);
5728 }
b7bd9ab6 5729 delete [] endcapsidecoverboxtrans;
5730 return endcapsidecovermother;
9b0c60ab 5731 }
5732 ////////////////////////////////////////////////////////////////////////////////
5733 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5734 ////////////////////////////////////////////////////////////////////////////////
5735 // Method returning Interface Card A, Interface Card B, Supply Card
5736 ////////////////////////////////////////////////////////////////////////////////
5737 /////////////////////
5738 // Supply Card
5739 /////////////////////
5740 // Electronic Board Back Al Plane
5741 const Int_t kelectboardbackvertexnumber = 8;
5742 Double_t xelectboardback[kelectboardbackvertexnumber];
5743 Double_t yelectboardback[kelectboardbackvertexnumber];
5744 xelectboardback[0] = 0.0;
5745 xelectboardback[1] = xelectboardback[0];
5746 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5747 xelectboardback[3] = xelectboardback[2];
5748 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5749 xelectboardback[5] = xelectboardback[4];
5750 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5751 xelectboardback[7] = xelectboardback[6];
5752
5753 yelectboardback[0] = 0.0;
5754 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5755 yelectboardback[2] = yelectboardback[1];
5756 yelectboardback[3] = yelectboardback[0];
5757 yelectboardback[4] = yelectboardback[3];
5758 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5759 yelectboardback[6] = yelectboardback[5];
5760 yelectboardback[7] = yelectboardback[4];
5761 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5762 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5763 xelectboardback,yelectboardback);
5764 electboardbackshape->DefineSection(0,0.0);
5765 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5766 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5767 electboardbackshape,fSSDSupportRingAl);
5768 electboardback->SetLineColor(fColorAl);
5769 // Electronic Board Kapton Layer
5770 const Int_t kelectlayervertexnumber = 8;
5771 Double_t xelectlayer[kelectlayervertexnumber];
5772 Double_t yelectlayer[kelectlayervertexnumber];
5773 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5774 xelectlayer[1] = xelectlayer[0];
5775 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5776 xelectlayer[3] = xelectlayer[2];
5777 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5778
5779 yelectlayer[0] = 0.0;
5780 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5781 yelectlayer[2] = yelectlayer[1];
5782 yelectlayer[3] = yelectlayer[0];
5783 yelectlayer[4] = yelectlayer[3];
5784 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5785 yelectlayer[6] = yelectlayer[5];
5786 yelectlayer[7] = yelectlayer[4];
5787 TGeoXtru* electlayershape = new TGeoXtru(2);
5788 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5789 electlayershape->DefineSection(0,0.0);
5790 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5791 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5792 electlayershape,fSSDKaptonFlexMedium);
5793 electlayer->SetLineColor(fColorKapton);
5794 // JMD Connector Female
5795 const Int_t kjmdconnectorvertexnumber = 6;
5796 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5797 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5798 xjmdconnectorvertex[0] = 0.0;
5799 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5800 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5801 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5802 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5803 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5804
5805 yjmdconnectorvertex[0] = 0.0;
5806 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5807 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5808 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5809 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5810 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5811 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5812 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5813 yjmdconnectorvertex);
5814 jmdconnectorshape->DefineSection(0,0.0);
5815 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5816 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5817 jmdconnectorshape,fSSDMountingBlockMedium);
5818 jmdconnector->SetLineColor(fColorG10);
5819 // Top Cable Connector
5820 const Int_t kcableconnectorvertexnumber = 8;
5821 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5822 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5823 xconnectorvertex[0] = 0.0;
5824 xconnectorvertex[1] = xconnectorvertex[0];
5825 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5826 xconnectorvertex[3] = xconnectorvertex[2];
5827 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5828 - fgkEndCapCardCableConnectorLength[2];
5829 xconnectorvertex[5] = xconnectorvertex[4];
5830 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5831 xconnectorvertex[7] = xconnectorvertex[6];
5832
5833 yconnectorvertex[0] = 0.0;
5834 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5835 yconnectorvertex[2] = yconnectorvertex[1];
5836 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5837 yconnectorvertex[4] = yconnectorvertex[3];
5838 yconnectorvertex[5] = yconnectorvertex[1];
5839 yconnectorvertex[6] = yconnectorvertex[5];
5840 yconnectorvertex[7] = yconnectorvertex[0];
5841 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5842 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5843 yconnectorvertex);
5844 cableconnectorshape->DefineSection(0,0.0);
5845 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5846 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5847 cableconnectorshape,fSSDMountingBlockMedium);
5848 cableconnector->SetLineColor(fColorG10);
5849 // Strip Connection
5850 TGeoBBox* endcapstripconnectionshape =
5851 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5852 0.5*fgkEndCapStripConnectionThickness,
5853 0.5*fgkEndCapStripConnectionWidth);
5854 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5855 endcapstripconnectionshape,
5856 fSSDSupportRingAl);
5857 endcapstripconnection->SetLineColor(fColorAl);
5858 // Interface Card B
5859 const Int_t kcardBvertexnumber = 12;
5860 Double_t xcardBvertexnumber[kcardBvertexnumber];
5861 Double_t ycardBvertexnumber[kcardBvertexnumber];
5862
5863 xcardBvertexnumber[0] = 0.0;
5864 xcardBvertexnumber[1] = xcardBvertexnumber[0];
5865 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5866 xcardBvertexnumber[3] = xcardBvertexnumber[2];
5867 xcardBvertexnumber[4] = xcardBvertexnumber[1];
5868 xcardBvertexnumber[5] = xcardBvertexnumber[4];
5869 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5870 xcardBvertexnumber[7] = xcardBvertexnumber[6];
5871 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5872 xcardBvertexnumber[9] = xcardBvertexnumber[8];
5873 xcardBvertexnumber[10] = xcardBvertexnumber[7];
5874 xcardBvertexnumber[11] = xcardBvertexnumber[10];
5875
5876 ycardBvertexnumber[0] = 0.0;
5877 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
5878 ycardBvertexnumber[2] = ycardBvertexnumber[1];
5879 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5880 ycardBvertexnumber[4] = ycardBvertexnumber[3];
5881 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5882 ycardBvertexnumber[6] = ycardBvertexnumber[5];
5883 ycardBvertexnumber[7] = ycardBvertexnumber[4];
5884 ycardBvertexnumber[8] = ycardBvertexnumber[7];
5885 ycardBvertexnumber[9] = ycardBvertexnumber[1];
5886 ycardBvertexnumber[10] = ycardBvertexnumber[9];
5887 ycardBvertexnumber[11] = ycardBvertexnumber[0];
5888
5889 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5890 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5891 interfacecardBshape->DefineSection(0,0.);
5892 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5893 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5894 fSSDMountingBlockMedium);
5895 interfacecardB->SetLineColor(46);
5896 // Interface Card B Electronic Board
5897 const Int_t kelectboardcardBvertexnumber = 14;
5898 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5899 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5900
5901 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5902 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
5903 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
5904 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
5905 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
5906 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
5907 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
5908 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
5909 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
5910 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
5911 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
5912 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
5913 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
5914 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
5915
5916 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
5917 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
5918 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
5919 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
5920 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
5921 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
5922 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
5923 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
5924 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
5925 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
5926 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
5927 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
5928 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
5929 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
5930
5931 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
5932 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
5933 xelectboardcardBvertex,yelectboardcardBvertex);
5934 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
5935 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
5936 + fgkEndCapInterfaceElectBoardCardBThickness);
5937 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
5938 fSSDSupportRingAl);
5939 electboardcardB->SetLineColor(fColorAl);
5940 // Generating Stiffener 2
5941 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
5942 0.5*fgkEndCapStiffenerThickness,
5943 0.5*fgkEndCapStiffenerLength);
5944 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
5945 endcapstiffener->SetLineColor(fColorAl);
5946 // Generating Mother Interface Card B Container
5947 const Int_t kinterfacecardBmothervertexnumber = 10;
5948 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5949 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5950
5951 xinterfacecardBmothervertex[0] = 0.0;
5952 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
5953 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
5954 + fgkEndCapInterfaceCardBThickness;
5955 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
5956 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
5957 + fgkEndCapInterfaceElectBoardCardBThickness;
5958 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
5959 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
5960 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
5961 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
5962 + fgkEndCapCardJMDConnectorLength[0];
5963 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
5964
5965 yinterfacecardBmothervertex[0] = 0.0;
5966 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
5967 + fgkEndCapInterfaceCardBWidth[1]
5968 + fgkEndCapInterfaceCardBWidth[2];
5969 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
5970 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
5971 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
5972 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
5973 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
5974 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
5975 + fgkEndCapCardJMDConnectorWidth[0]
5976 + fgkEndCapCardJMDConnectorWidth[1];
5977 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
5978 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
5979 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
5980 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
5981 xinterfacecardBmothervertex,
5982 yinterfacecardBmothervertex);
5983 interfacecardBmothershape->DefineSection(0,-1.e-15);
5984 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
5985 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
5986 interfacecardBmothershape,fSSDAir);
5987 electboardcardB->SetLineColor(fColorAl);
5988 // Positioning Volumes Mother Interface Card B Container
5989 TGeoRotation* interfacecardBrot = new TGeoRotation();
5990 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
5991 interfacecardBrot->SetAngles(90.,-90.,-90.);
5992 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
5993 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
5994 TGeoRotation* electboardcardBrot = new TGeoRotation();
5995 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
5996 electboardcardBrot->SetAngles(90.,90.,-90.);
5997 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
5998 TGeoCombiTrans* electboardcardBcombitrans =
5999 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6000 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6001 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6002 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6003 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6004 TGeoTranslation* jmdconnectorcardBtrans[3];
6005 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6006 for(Int_t i=0; i<3; i++){
6007 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6008 + fgkEndCapCardJMDConnectorLength[0],
6009 fgkEndCapCardElectBoardLayerWidth[1],
6010 0.5*fgkEndCapCardJMDConnectorThickness
6011 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6012 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6013 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6014 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6015 *jmdconnectorcardBrot);
6016 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6017 }
6018 // Mother Supply Card Container
6019 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6020 // Interface Card Container
6021 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6022 // Placing Volumes in Mother Supply Card Container
6023 // JMD Connector Positioning
6024 TGeoTranslation* jmdconnectortrans[2];
6025 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6026 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6027 fgkEndCapCardElectBoardBackLength[0]
6028 - fgkEndCapCardJMDConnectorThickness
6029 - fgkEndCapCardJMDConnectorToLayer);
6030 TGeoRotation* jmdconnectorot = new TGeoRotation();
6031 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6032 + 2.*fgkEndCapCardJMDConnectorLength[0]
6033 + 2.*fgkEndCapCardElectBoardLayerThickness,
6034 fgkEndCapCardElectBoardLayerWidth[1],
6035 fgkEndCapCardJMDConnectorThickness
6036 + fgkEndCapCardJMDConnectorToLayer);
6037 jmdconnectorot->SetAngles(90.,180.,-90);
6038 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6039 * jmdconnectorot);
6040 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6041 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6042 // Top Cable Connector Placing
6043 TGeoRotation* cableconnectorot[2];
6044 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6045 TGeoTranslation* cableconnectortrans[3];
6046 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6047 cableconnectorot[0]->SetAngles(90.,0.,0.);
6048 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6049 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6050 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6051 *cableconnectorot[0]);
6052 TGeoHMatrix* cableconnectormatrix[2];
6053 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6054 new TGeoHMatrix((*cableconnectorot[1])
6055 *(*cableconnectorcombitrans));
6056 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6057 - fgkEndCapCardCableConnectorThickness,
6058 fgkEndCapCardCableConnectorLength[0]
6059 + fgkEndCapCardCableConnectorToLayer);
6060 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6061 - 2.*fgkEndCapCardCableConnectorThickness
6062 - fgkEndCapCardCableConnectorDistance,
6063 fgkEndCapCardCableConnectorLength[0]
6064 + fgkEndCapCardCableConnectorToLayer);
6065 for(Int_t i=0; i<2; i++){
6066 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6067 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6068 }
6069 TGeoRotation* electboardbackrot = new TGeoRotation();
6070 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6071 electboardbackrot->SetAngles(90.,-90.,-90.);
6072 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6073 + fgkEndCapCardJMDConnectorLength[0]
6074 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6075 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6076 *electboardbackrot);
6077 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6078 // Electronic Board Kapton Layer Positioning
6079 TGeoRotation* electlayerrot = new TGeoRotation();
6080 TGeoTranslation* electlayertrans[2];
6081 TGeoCombiTrans* electlayercombitrans[2];
6082 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6083 electlayerrot->SetAngles(90.,-90.,-90.);
6084 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6085 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6086 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6087 + 2.*fgkEndCapCardElectBoardLayerThickness
6088 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6089 for(Int_t i=0; i<2; i++){
6090 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6091 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6092 }
6093 // Placing Volumes in Mother Interface Card Container
6094 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6095 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6096 for(Int_t i=0; i<2; i++){
6097 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6098 }
6099 /////////////////////////////////////////////////////////////
6100 // Generation of Card Interface Container
6101 /////////////////////////////////////////////////////////////
6102 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6103 - fgkEndCapCardJMDConnectorLength[0]
6104 - fgkEndCapInterfaceCardBThickness
6105 - 9.*fgkEndCapStripConnectionThickness
6106 - 8.*fgkEndCapCardElectBoardBackThickness;
6107 const Int_t kcardinterfacecontainervertexnumber = 14;
6108 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6109 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6110 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6111 - 7.0*fgkEndCapStripConnectionThickness;
6112 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6113 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6114 + fgkEndCapStripConnectionThickness
6115 - fgkEndCapCardElectBoardLayerThickness
6116 - fgkEndCapCardCableConnectorWidth[0];
6117 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6118 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6119 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6120 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6121 + 2.0*fgkEndCapStripConnectionThickness;
6122 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6123 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6124 + fgkEndCapInterfaceCardBThickness;
6125 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6126 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6127 + fgkEndCapInterfaceElectBoardCardBThickness;
6128 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6129 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6130 - fgkEndCapInterfaceElectBoardCardBThickness
6131 + fgkEndCapCardJMDConnectorLength[0]
6132 + stiffenertransx+fgkEndCapStiffenerWidth;
6133 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6134
6135 ycardinterfacecontainervertex[0] = 0.;
6136 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6137 + fgkEndCapCardJMDConnectorWidth[0]
6138 + fgkEndCapCardJMDConnectorWidth[1];
6139 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6140 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6141 - fgkEndCapStripConnectionWidth;
6142 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6143 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6144 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6145 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6146 + fgkEndCapInterfaceCardBWidth[1]
6147 + fgkEndCapInterfaceCardBWidth[2];
6148 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6149 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6150 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6151 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6152 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6153 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6154
6155 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6156 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6157 xcardinterfacecontainervertex,
6158 ycardinterfacecontainervertex);
6159 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6160 - fgkEndCapCardElectBoardBackLength[0]));
6161 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6162 + fgkEndCapCardElectBoardBackLength[0]));
6163 TGeoVolume** cardinterfacecontainer;
6164 cardinterfacecontainer = new TGeoVolume*[4];
6165 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6166 interfacecardmothershape,fSSDAir);
6167 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6168 interfacecardmothershape,fSSDAir);
6169 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6170 interfacecardmothershape,fSSDAir);
6171 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6172 interfacecardmothershape,fSSDAir);
6173 /////////////////////////////////
6174 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6175 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6176 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6177 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6178 /////////////////////////////////
6179 TGeoRotation* endcapstripconnectionrot[2];
6180 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6181 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6182 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6183 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6184 * (*endcapstripconnectionrot[0]));
6185 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6186 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6187 -0.5*fgkEndCapCardElectBoardBackThickness,
6188 fgkEndCapCardElectBoardBackWidth[0]
6189 -endcapstripconnectionshape->GetDZ(),
6190 0.5*fgkEndCapCardElectBoardBackLength[0]);
6191 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6192 TGeoTranslation* cardinterfacetrans[9];
6193 TGeoHMatrix* cardinterfacematrix[9];
6194 for(Int_t i=0; i<7; i++){
6195 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6196 + fgkEndCapCardElectBoardBackThickness),
6197 0.0,0.0);
6198 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6199 * (*endcapstripconnectionmatrix));
6200 }
6201 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6202 + fgkEndCapCardElectBoardBackThickness),
6203 0.0,0.0);
6204 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6205 * (*endcapstripconnectionmatrix));
6206 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6207 + fgkEndCapCardElectBoardBackThickness),
6208 0.0,0.0);
6209 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6210 * (*endcapstripconnectionmatrix));
6211
6212 for(Int_t i=0; i<4; i++){
6213 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6214 cardinterfacematrix[7]);
6215 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6216 cardinterfacematrix[8]);
6217 }
6218 TGeoTranslation* mothersupplycardtrans =
6219 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6220 + 2.*fgkEndCapCardJMDConnectorLength[0]
6221 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6222 TGeoHMatrix* mothersupplycardmatrix[7];
6223 Int_t index[4] = {1,1,1,1};
6224 for(Int_t i=0; i<7; i++){
6225 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6226 * (*mothersupplycardtrans));
6227 for(Int_t j=0; j<4; j++){
6228 switch(j){
6229 case 0: //Layer5 EndCap Left Side
6230 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6231 cardinterfacematrix[i]);
6232 if(i!=0){
6233 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6234 mothersupplycardmatrix[i]);
6235 index[j]++;
6236
6237 }
6238 break;
6239 case 1: //Layer5 EndCap Rigth Side
6240 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6241 cardinterfacematrix[i]);
6242 if(i>0&&i<6){
6243 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6244 mothersupplycardmatrix[i]);
6245 index[j]++;
6246 }
6247 break;
6248 case 2: //Layer6 EndCap Left Side
6249 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6250 cardinterfacematrix[i]);
6251 if(i!=6){
6252 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6253 mothersupplycardmatrix[i]);
6254 index[j]++;
6255 }
6256 break;
6257 case 3: //Layer6 EndCap Right Side
6258 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6259 cardinterfacematrix[i]);
6260 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6261 mothersupplycardmatrix[i]);
6262 index[j]++;
6263 break;
6264 }
6265 }
6266 }
6267 // Positioning Interface
6268 TGeoTranslation* motherinterfacecardtrans =
6269 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6270 +0.5*fgkEndCapCardElectBoardBackThickness
6271 -fgkEndCapCardElectBoardLayerThickness
6272 +fgkEndCapStripConnectionThickness,0.,0.);
6273 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6274 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6275 // Positioning Interface Card B
6276 TGeoTranslation* interfacecardBmothertrans =
6277 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6278 + 2.*fgkEndCapStripConnectionThickness
6279 + fgkEndCapCardElectBoardBackThickness,0.,
6280 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6281 - fgkEndCapCardElectBoardBackLength[0]));
6282 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6283 interfacecardBmothertrans);
6284 // Positioning Stiffener
6285 TGeoTranslation* endcapstiffenertrans =
6286 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6287 + 2.0*fgkEndCapStripConnectionThickness
6288 + fgkEndCapInterfaceCardBThickness
6289 + fgkEndCapCardJMDConnectorLength[0]
6290 + stiffenertransx
6291 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6292 endcapstiffenershape->GetDZ()
6293 - 0.5*(fgkEndCapStiffenerLength
6294 - fgkEndCapCardElectBoardBackLength[0]));
6295 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6296 /////////////////////////////////////////////////////////////
6297 // Deallocating memory
6298 /////////////////////////////////////////////////////////////
6299 delete interfacecardBrot;
6300 delete interfacecardBtrans;
6301 delete electboardcardBtrans;
6302 delete electboardcardBrot;
6303 delete jmdconnectorcardBrot;
6304 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6305 delete jmdconnectorot;
6306 delete jmdconnectortrans[1];
6307 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6308 delete cableconnectorcombitrans;
6309 delete electboardbacktrans;
6310 delete electboardbackrot;
6311 delete electlayerrot;
6312 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6313 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6314 delete mothersupplycardtrans;
6315 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6316 /////////////////////////////////////////////////////////////
6317 return cardinterfacecontainer;
6318 }
6319 ////////////////////////////////////////////////////////////////////////////////
6320 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6321 /////////////////////////////////////////////////////////////
6322 // Method returning EndCap Mother Volume
6323 /////////////////////////////////////////////////////////////
6324 const Int_t kendcapcoverplatesmallholenumber = 9;
6325 Double_t endcapmotherorigin[3];
6326 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6327 + 0.5 *(fgkEndCapCoverPlateLength[3]
6328 + 2.0 * fgkEndCapCoverPlateLength[2]);
6329 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6330 - fgkEndCapCoverPlateWidth[2]
6331 - (kendcapcoverplatesmallholenumber-1)
6332 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6333 + 0.5*(fgkEndCapSideCoverLength[2]
6334 + fgkEndCapCoverPlateWidth[1]
6335 - fgkEndCapCoverPlateWidth[0])
6336 - (fgkEndCapCoverPlateWidth[1]
6337 - fgkEndCapCoverPlateWidth[0]);
6338 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6339 + 2.*fgkEndCapCoolingTubeRadiusMax
6340 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6341 + fgkEndCapSideCoverWidth[1]
6342 + fgkEndCapSideCoverThickness
6343 + fgkEndCapKaptonFoilThickness);
6344 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6345 + 2.0* fgkEndCapCoverPlateLength[2]
6346 + 2.0* fgkEndCapSideCoverThickness),
6347 0.5* (fgkEndCapSideCoverLength[2]
6348 + fgkEndCapCoverPlateWidth[1]
6349 - fgkEndCapCoverPlateWidth[0]),
6350 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6351 + fgkEndCapSideCoverWidth[1]
6352 + fgkEndCapSideCoverThickness
6353 + fgkEndCapKaptonFoilThickness),
6354 endcapmotherorigin);
6355 TGeoVolume** endcapassembly;
6356 endcapassembly = new TGeoVolume*[4];
6357 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6358 endcapmothershape,fSSDAir);
6359 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6360 endcapmothershape,fSSDAir);
6361 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6362 endcapmothershape,fSSDAir);
6363 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6364 endcapmothershape,fSSDAir);
6365 /////////////////////////////////
6366 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6367 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6368 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6369 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6370 /////////////////////////////////
6371 /////////////////////////////////////////////////////
6372 // Placing Endcap Cover Plate
6373 /////////////////////////////////////////////////////
6374 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6375 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6376 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6377 TGeoCombiTrans* endcapcoverplatecombitrans =
6378 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6379 endcapcoverplaterot);
6380 TGeoTranslation* endcapcoverplatetrans =
6381 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6382 TGeoHMatrix* endcapcoverplatematrix =
6383 new TGeoHMatrix((*endcapcoverplatetrans)
6384 * (*endcapcoverplatecombitrans));
6385 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6386 /////////////////////////////////////////////////////
6387 // Placing Endcap Side Cover
6388 /////////////////////////////////////////////////////
6389 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6390 TGeoRotation* endcapsidecoverot[2];
6391 TGeoCombiTrans* endcapsidecovercombitrans[3];
6392 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6393 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6394 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6395 - 0.5*(fgkEndCapCoverPlateWidth[0]
6396 - fgkEndCapCoverPlateWidth[2]
6397 - (kendcapcoverplatesmallholenumber-1)
6398 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6399 + 0.*fgkEndCapCoverPlateWidth[0]
6400 + fgkEndCapSideCoverLength[2],
6401 0.5*(fgkEndCapSideCoverThickness
6402 + fgkEndCapCoverPlateThickness)
6403 - 0.5*fgkEndCapCoverPlateThickness,
6404 endcapsidecoverot[0]);
6405 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6406 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6407 0.5*fgkEndCapCoverPlateThickness
6408 -fgkEndCapSideCoverWidth[1],
6409 endcapsidecoverot[1]);
6410 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6411 +fgkEndCapCoverPlateLength[3]
6412 +2.*fgkEndCapCoverPlateLength[2]
6413 +fgkEndCapSideCoverThickness,0.0,
6414 0.5*fgkEndCapCoverPlateThickness
6415 -fgkEndCapSideCoverWidth[1],
6416 endcapsidecoverot[1]);
6417 TGeoHMatrix* endcapsidecovermatrix[2];
6418 for(Int_t i=0; i<2; i++){
6419 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6420 * (*endcapsidecovercombitrans[0]));
6421 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6422 endcapsidecovermatrix[i]);
6423 }
6424 /////////////////////////////////////////////////////
6425 // Placing Endcap Cooling Tube
6426 /////////////////////////////////////////////////////
6427 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6428 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6429 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6430 TGeoCombiTrans* endcapccolingtubecombitrans
6431 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6432 + fgkEndCapCoolingTubeAxialRadius[1])
6433 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6434 - fgkEndCapCoolingTubeToCoverSide,
6435 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6436 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6437 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6438 endcapccolingtubecombitrans);
6439 /////////////////////////////////////////////////////
6440 // Placing Screws
6441 /////////////////////////////////////////////////////
6442 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6443 fgkEndCapCoverPlateScrewRadiusMin};
6444 Int_t screwcoverplatedgesnumber[2] = {20,20};
6445 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6446 fgkEndCapCoverPlateThickness
6447 + fgkEndCapCoolingTubeRadiusMax};
851c0ce3 6448 TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
9b0c60ab 6449 screwcoverplatedgesnumber,
6450 screwcoverplatesection);
6451 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6452 screwcoverplateshape,
6453 fSSDCoolingTubePhynox);
6454 screwcoverplate->SetLineColor(12);
6455 Double_t transx[4] = {0,
6456 fgkEndCapCoverPlateSmallHoleSeparation[0],
6457 fgkEndCapCoverPlateSmallHoleSeparation[0]
6458 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6459 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6460 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6461 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6462// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6463 TGeoTranslation*** endcapcoverplatescrewtrans;
6464 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6465 Int_t index = 0;
6466 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6467 endcapcoverplatescrewtrans[i] =
6468 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6469 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6470 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6471 if(index==1||index==9||index==28||index==36){
6472 endcapcoverplatescrewtrans[i][j] =
6473 new TGeoTranslation(transx[i],
6474 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6475 fgkEndCapSideCoverThickness);
6476 }
6477 else{
6478 endcapcoverplatescrewtrans[i][j] =
6479 new TGeoTranslation(transx[i],
6480 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6481 0.);
6482 }
6483 if(index!=19)
6484 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6485 endcapcoverplatescrewtrans[i][j]);
6486 }
6487 }
6488 /////////////////////////////////////////////////////
6489 // Placing Cover Plate Clips
6490 /////////////////////////////////////////////////////
6491 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6492 0.5*fgkEndCapCoverPlateClipWidth,
6493 0.5*fgkEndCapSideCoverThickness);
6494 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6495 endcapcoverplateclipshape,
6496 fSSDCoolingTubePhynox);
6497 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6498 0.5*fgkEndCapCoverPlateDownClipWidth,
6499 0.5*fgkEndCapSideCoverThickness);
6500 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6501 endcapcoverplatedownclipshape,
6502 fSSDCoolingTubePhynox);
6503 TGeoTranslation* endcapcoverplatecliptrans[4];
6504 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6505 - fgkEndCapCoverPlateLength[0]
6506 - fgkEndCapSideCoverThickness,
6507 0.0,
6508 0.5*(fgkEndCapSideCoverThickness
6509 + fgkEndCapCoverPlateThickness));
6510 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6511 - fgkEndCapCoverPlateLength[0]
6512 - fgkEndCapSideCoverThickness,
6513 (kendcapcoverplatescrewnumber[1]-1)
6514 * fgkEndCapSideCoverWidth[5],
6515 0.5*(fgkEndCapSideCoverThickness
6516 + fgkEndCapCoverPlateThickness));
6517 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6518 - fgkEndCapCoverPlateLength[0]
6519 + fgkEndCapCoverPlateLength[1]
6520 + 2.*fgkEndCapCoverPlateLength[0]
6521 - fgkEndCapCoverPlateClipLength
6522 + fgkEndCapSideCoverThickness,
6523 0.0,
6524 0.5*(fgkEndCapSideCoverThickness
6525 + fgkEndCapCoverPlateThickness));
6526 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6527 - fgkEndCapCoverPlateLength[0]
6528 + fgkEndCapCoverPlateLength[1]
6529 + 2.*fgkEndCapCoverPlateLength[0]
6530 - fgkEndCapCoverPlateClipLength
6531 + fgkEndCapSideCoverThickness,
6532 (kendcapcoverplatescrewnumber[1]-1)
6533 * fgkEndCapSideCoverWidth[5],
6534 0.5*(fgkEndCapSideCoverThickness
6535 + fgkEndCapCoverPlateThickness));
6536 endcapcoverplateclip->SetLineColor(fColorPhynox);
6537 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6538 for(Int_t i=0; i<4; i++)
6539 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6540 endcapcoverplatecliptrans[i]);
6541 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6542 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6543 - fgkEndCapCoverPlateLength[0]
6544 - fgkEndCapSideCoverThickness,
6545 0.5*(fgkEndCapCoverPlateDownClipWidth
6546 - fgkEndCapCoverPlateClipWidth),
6547 0.5*(fgkEndCapSideCoverThickness
6548 + fgkEndCapCoverPlateThickness)
6549 - fgkEndCapSideCoverWidth[1]
6550 - fgkEndCapSideCoverThickness);
6551 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6552 - fgkEndCapCoverPlateLength[0]
6553 - fgkEndCapSideCoverThickness,
6554 0.5*(fgkEndCapCoverPlateDownClipWidth
6555 - fgkEndCapCoverPlateClipWidth)
6556 + fgkEndCapSideCoverLength[2]
6557 - fgkEndCapCoverPlateDownClipWidth,
6558 0.5*(fgkEndCapSideCoverThickness
6559 + fgkEndCapCoverPlateThickness)
6560 - fgkEndCapSideCoverWidth[1]
6561 - fgkEndCapSideCoverThickness);
6562 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6563 - fgkEndCapCoverPlateLength[0]
6564 + fgkEndCapSideCoverThickness
6565 + fgkEndCapCoverPlateLength[1]
6566 + 2.0*fgkEndCapCoverPlateLength[0]
6567 - fgkEndCapCoverPlateDownClipLength,
6568 0.5*(fgkEndCapCoverPlateDownClipWidth
6569 - fgkEndCapCoverPlateClipWidth),
6570 0.5*(fgkEndCapSideCoverThickness
6571 + fgkEndCapCoverPlateThickness)
6572 - fgkEndCapSideCoverWidth[1]
6573 - fgkEndCapSideCoverThickness);
6574 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6575 - fgkEndCapCoverPlateLength[0]
6576 + fgkEndCapSideCoverThickness
6577 + fgkEndCapCoverPlateLength[1]
6578 + 2.0*fgkEndCapCoverPlateLength[0]
6579 - fgkEndCapCoverPlateDownClipLength,
6580 0.5*(fgkEndCapCoverPlateDownClipWidth
6581 - fgkEndCapCoverPlateClipWidth)
6582 + fgkEndCapSideCoverLength[2]
6583 - fgkEndCapCoverPlateDownClipWidth,
6584 0.5*(fgkEndCapSideCoverThickness
6585 + fgkEndCapCoverPlateThickness)
6586 - fgkEndCapSideCoverWidth[1]
6587 - fgkEndCapSideCoverThickness);
6588 for(Int_t i=0; i<4; i++)
6589 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6590 endcapcoverplatedowncliptrans[i]);
6591 /////////////////////////////////////////////////////
6592 // Placing Kapton Foil
6593 /////////////////////////////////////////////////////
6594 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6595 0.5*fgkEndCapKaptonFoilWidth,
6596 0.5*fgkEndCapKaptonFoilThickness);
6597 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6598 endcapkaptonfoilshape,
6599 fSSDKaptonFlexMedium);
6600 endcapkaptonfoil->SetLineColor(8);
6601 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6602 0.5*fgkEndCapKaptonFoilWidth
6603 - 0.5*fgkEndCapCoverPlateClipWidth,
6604 0.5*fgkEndCapCoverPlateThickness
6605 - 0.5*fgkEndCapKaptonFoilThickness
6606 - fgkEndCapSideCoverWidth[1]
6607 - fgkEndCapSideCoverThickness);
6608 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6609 /////////////////////////////////////////////////////////////
6610 // Placing Electronic Tubes
6611 /////////////////////////////////////////////////////////////
6612 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6613 - fgkEndCapInterfaceCardBThickness
6614 - 9.*fgkEndCapStripConnectionThickness
6615 - 8.*fgkEndCapCardElectBoardBackThickness,
6616 fgkEndCapKaptonFoilWidth
6617 - fgkEndCapInterfaceCardBThickness
6618 - 9.*fgkEndCapStripConnectionThickness
6619 - 8.*fgkEndCapCardElectBoardBackThickness
6620 - fgkEndCapInterfaceElectBoardCardBThickness};
6621 TGeoVolume* endcapeffectivecables[2];
6622 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6623 fgkEndCapEffectiveCableRadiusMax,
6624 endcapeffectivecableswidth[0],
6625 10,"EndCapEffectiveCables1");
6626 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6627 fgkEndCapEffectiveCableRadiusMax,
6628 endcapeffectivecableswidth[1],
6629 25,"EndCapEffectiveCables2");
6630 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6631 TGeoTranslation* endcapeffectivecablestrans[2];
6632 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6633 - 0.5*endcapeffectivecableswidth[0]
6634 - 0.5*(fgkEndCapCoverPlateWidth[0]
6635 - fgkEndCapCoverPlateWidth[2]
6636 - (kendcapcoverplatesmallholenumber-1)
6637 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6638 + fgkEndCapSideCoverLength[2],
6639 - 0.5*fgkEndCapCoverPlateThickness
6640 - (fgkEndCapCardElectBoardBackWidth[0]
6641 - fgkEndCapInterfaceCardBWidth[0]
6642 - fgkEndCapInterfaceCardBWidth[1]));
6643 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6644 - 0.5*endcapeffectivecableswidth[1]
6645 - 0.5*(fgkEndCapCoverPlateWidth[0]
6646 - fgkEndCapCoverPlateWidth[2]
6647 - (kendcapcoverplatesmallholenumber-1)
6648 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6649 + fgkEndCapSideCoverLength[2],
6650 - 0.5*fgkEndCapCoverPlateThickness
6651 - (fgkEndCapCardElectBoardBackWidth[0]
6652 - fgkEndCapInterfaceCardBWidth[0])
6653 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6654 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6655 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6656 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6657 *endcapeffectivecablesrot);
6658 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6659 *endcapeffectivecablesrot);
47f8de53 6660// for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6661// endcapeffectivecablescombitrans[0]);
9b0c60ab 6662 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6663 endcapeffectivecablescombitrans[1]);
6664 /////////////////////////////////////////////////////////////
6665 // Placing End Cap Cards
6666 /////////////////////////////////////////////////////////////
6667 TGeoVolume** endcapcards = GetEndCapCards();
6668 TGeoRotation* endcapcardsrot[2];
6669 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6670 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6671 TGeoTranslation* endcapcardstrans[2];
6672 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6673 - fgkEndCapCardElectBoardBackLength[0]));
6674 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6675 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6676 TGeoHMatrix* endcapcardsmatrix[2];
6677 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6678 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6679 - fgkEndCapCardJMDConnectorLength[0]
6680 - fgkEndCapInterfaceCardBThickness
6681 - 9.*fgkEndCapStripConnectionThickness
6682 - 8.*fgkEndCapCardElectBoardBackThickness;
6683 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6684 - fgkEndCapCoverPlateLength[0]
6685 + 0.5 * (fgkEndCapCoverPlateLength[3]
6686 + 2.0 * fgkEndCapCoverPlateLength[2]),
6687 - stiffenertransx-fgkEndCapStiffenerWidth
6688 - fgkEndCapCardJMDConnectorLength[0]
6689 - fgkEndCapInterfaceCardBThickness
6690 - 2.0 * fgkEndCapStripConnectionThickness
6691 - 1.5 * fgkEndCapInterfaceCardBThickness
6692 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6693 - fgkEndCapCoverPlateWidth[2]
6694 - (kendcapcoverplatesmallholenumber-1)
6695 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6696 + fgkEndCapKaptonFoilWidth,
6697 0.5*fgkEndCapCoverPlateThickness
6698 - fgkEndCapSideCoverWidth[1]);
6699 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6700 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6701 /////////////////////////////////////////////////////////////
6702 // Deallocating memory
6703 /////////////////////////////////////////////////////////////
6704 delete endcapcoverplaterot;
6705 delete endcapcoverplatecombitrans;
6706 delete endcapcoverplatetrans;
6707 for(Int_t i=0; i<3; i++){
6708 delete endcapsidecovercombitrans[i];
6709 if(i<2) delete endcapsidecoverot[i];
6710 }
6711 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6712 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6713 delete endcapcardsmatrix[0];
6714 return endcapassembly;
6715 }
6716 ////////////////////////////////////////////////////////////////////////////////
6717 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6718 Double_t radiusmax,
6719 Double_t width,
6720 Int_t ncables,
a6e0ebfe 6721 const char* volname){
9b0c60ab 6722 /////////////////////////////////////////////////////////////
6723 // Generating EndCap High Voltage Tubes
6724 /////////////////////////////////////////////////////////////
6725 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
60e55aee 6726 Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6727
9b0c60ab 6728 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6729 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6730 effectiveouteradius,0.5*width);
6731 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6732 effectiveinnertubeshape,
6733 fSSDStiffenerConnectorMedium);
6734 effectiveinnertube->SetLineColor(41);
6735 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6736 effectiveoutertubeshape,
6737 fSSDKaptonChipCableMedium);
6738 effectiveoutertube->SetLineColor(39);
6739 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6740 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6741 effectivemothertube->AddNode(effectiveinnertube,1);
6742 effectivemothertube->AddNode(effectiveoutertube,1);
6743 return effectivemothertube;
6744 }
6745 ////////////////////////////////////////////////////////////////////////////////
6746 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6747 /////////////////////////////////////////////////////////////
6748 // Generating EndCap Support Layer 5 and Layer 6
6749 /////////////////////////////////////////////////////////////
6750 const Int_t knedges = 5;
6751 ///////////////////////////////////////////////
6752 // Setting the vertices for TGeoXtru Up Volume
6753 ///////////////////////////////////////////////
6754 const Int_t klayernumber = 2;
6755 Double_t xupvertex[klayernumber][knedges+3];
6756 Double_t yupvertex[klayernumber][knedges+3];
6757 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6758 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6759 Double_t middlepsi[klayernumber] = {0.0,0.0};
6760 for(Int_t i=0; i<klayernumber; i++){
6761 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6762 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6763 xupvertex[i][2] = -xupvertex[i][1];
6764 xupvertex[i][3] = -xupvertex[i][0];
6765
6766 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6767 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6768 yupvertex[i][2] = yupvertex[i][1];
6769 yupvertex[i][3] = yupvertex[i][0];
6770
6771 middledgeangle[i] = upedgeangle[i]/knedges;
6772 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6773 for(Int_t j=1; j<knedges; j++){
6774 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6775 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6776 }
6777 }
6778 ////////////////////////////////////
6779 // Generating Up TGeoXtru
6780 ////////////////////////////////////
6781 TGeoXtru* upendcapsupportshape[klayernumber];
6782 TGeoVolume* upendcapsupport[klayernumber];
a3f8715e 6783 char upendcapsupportname[100];
9b0c60ab 6784 for(Int_t i=0; i<klayernumber; i++){
6785 upendcapsupportshape[i] = new TGeoXtru(2);
045be90c 6786 snprintf(upendcapsupportname,100,"UpEndCapSupportPieceLayer%i",i+5);
9b0c60ab 6787 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6788 upendcapsupportshape[i]->DefineSection(0,0.);
6789 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6790 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 6791 fSSDSupportRingAl);
9b0c60ab 6792 upendcapsupport[i]->SetLineColor(5);
6793 }
6794 ///////////////////////////////////////////////
6795 // Setting the vertices for TGeoXtru Down Volume
6796 ///////////////////////////////////////////////
6797 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6798 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6799 for(Int_t i=0; i<klayernumber; i++){
6800 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6801 xdownvertex[i][1] = xupvertex[i][0];
6802 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6803 ydownvertex[i][1] = yupvertex[i][0];
6804 for(Int_t j=0; j<knedges; j++){
6805 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6806 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6807 }
6808 for(Int_t j=0; j<knedges; j++){
6809 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6810 * CosD(middlepsi[i]+j*middledgeangle[i]);
6811 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6812 * SinD(middlepsi[i]+j*middledgeangle[i]);
6813 }
6814 }
6815 ////////////////////////////////////
6816 // Generating Down TGeoXtru
6817 ////////////////////////////////////
6818 TGeoXtru* downendcapsupportshape[klayernumber];
6819 TGeoVolume* downendcapsupport[klayernumber];
a3f8715e 6820 char downendcapsupportname[100];
9b0c60ab 6821 for(Int_t i=0; i<klayernumber; i++){
6822 downendcapsupportshape[i] = new TGeoXtru(2);
045be90c 6823 snprintf(downendcapsupportname,100,"DownEndCapSupportPieceLayer%i",i+5);
9b0c60ab 6824 downendcapsupportshape[i] = new TGeoXtru(2);
6825 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6826 if(i==0){
6827 downendcapsupportshape[i]->DefineSection(0,0.);
6828 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6829 }
6830 else{
6831 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6832 - fgkEndCapSupportLowWidth[i]);
6833 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6834 }
6835 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 6836 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 6837 downendcapsupport[i]->SetLineColor(5);
6838 }
6839 ///////////////////////////////////////////////
6840 // Setting TGeoPgon Volume
6841 ///////////////////////////////////////////////
6842 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6843 fgkSSDLay6LadderNumber};
6844 TGeoPgon* endcapsupportmothershape[klayernumber];
6845 TGeoVolume** endcapsupportmother;
6846 endcapsupportmother = new TGeoVolume*[klayernumber];
a3f8715e 6847 char endcapsupportmothername[100];
9b0c60ab 6848 for(Int_t i=0; i<klayernumber; i++){
6849 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
045be90c 6850 snprintf(endcapsupportmothername,100,"EndCapSupportMotherLayer%i",i+5);
9b0c60ab 6851 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6852 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6853 ydownvertex[i][0],yupvertex[i][1]);
6854 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 6855 fSSDAir);
9b0c60ab 6856 }
6857 ////////////////////////////////////
6858 TGeoRotation** endcapsupportrot[klayernumber];
6859 for(Int_t i=0; i<2; i++){
6860 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6861 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6862 endcapsupportrot[i][j] = new TGeoRotation();
6863 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6864 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6865 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6866 }
6867 }
6868 return endcapsupportmother;
6869 }
6870 ////////////////////////////////////////////////////////////////////////////////
6871 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6872 /////////////////////////////////////////////////////////////
6873 // Setting End Cap Support Layer 5 and 6.
6874 /////////////////////////////////////////////////////////////
6875 const Int_t kendcapcoverplatesmallholenumber = 9;
6876 const Int_t klayernumber = 2;
6877 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6878 fgkSSDLay6LadderNumber};
6879 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6880 360.0/kssdlayladdernumber[1]};
6881 TGeoVolume** endcapsupport = EndCapSupport();
6882 TGeoVolume** endcapassembly = GetEndCapAssembly();
6883 TGeoPgon* endcapsupportshape[klayernumber];
6884 Double_t* radiusmin[klayernumber];
6885 Double_t* radiusmax[klayernumber];
6886 for(Int_t i=0; i<klayernumber; i++){
6887 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6888 radiusmin[i] = endcapsupportshape[i]->GetRmin();
6889 radiusmax[i] = endcapsupportshape[i]->GetRmax();
6890 }
6891 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6892 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6893 endcapassemblyshape->GetDY(),
6894 endcapassemblyshape->GetDZ()};
6895 ///////////////////////////////////////////////
6896 // Setting TGeoPgon Volume for Mother Container
6897 ///////////////////////////////////////////////
6898 TGeoPgon* endcapsupportsystemshape[klayernumber];
a3f8715e 6899 char endcapsupportsystemothername[100];
9b0c60ab 6900 for(Int_t i=0; i<klayernumber; i++){
6901 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
045be90c 6902 snprintf(endcapsupportsystemothername,100,"EndCapSupportSystemLayer%i",i+5);
9b0c60ab 6903 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
6904 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
6905 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6906 +2.*endcapassemblycenter[2])
6907 /CosD(0.5*upedgeangle[i]));
6908 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
6909 -(fgkEndCapCoverPlateWidth[1]
6910 - fgkEndCapCoverPlateWidth[0]),
6911 *radiusmin[i],
6912 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6913 +2.*endcapassemblycenter[2])
6914 /CosD(0.5*upedgeangle[i]));
6915 }
e5bf64ae 6916 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 6917 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
6918 endcapsupportsystemshape[0],fSSDAir);
6919 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
6920 endcapsupportsystemshape[0],fSSDAir);
6921 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
6922 endcapsupportsystemshape[1],fSSDAir);
6923 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
6924 endcapsupportsystemshape[1],fSSDAir);
6925 ///////////////////////////////////////////////
6926 TGeoTranslation* endcapassemblytrans[klayernumber];
6927 for(Int_t i=0; i<klayernumber; i++)
6928 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
6929 - fgkEndCapSideCoverThickness
6930 + endcapassemblycenter[0],
6931 - 0.5*fgkEndCapCoverPlateThickness
6932 - 2.0*fgkEndCapCoolingTubeRadiusMax
6933 + 2.0*endcapassemblycenter[2]
6934 + 0.5*fgkEndCapSupportLength[i]
6935 / TanD(0.5*upedgeangle[i]),
6936 0.5*(fgkEndCapCoverPlateWidth[0]
6937 - fgkEndCapCoverPlateWidth[2]
6938 - (kendcapcoverplatesmallholenumber-1)
6939 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
6940 TGeoRotation** endcapassemblyrot[klayernumber];
6941 TGeoHMatrix** endcapassemblymatrix[klayernumber];
6942 for(Int_t i=0; i<klayernumber; i++){
6943 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
6944 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
6945 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
6946 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
6947 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
6948 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
6949 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
6950 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6951 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
6952 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
6953 }
6954 }
6955 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
6956 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
6957 for(Int_t i=0; i<2*klayernumber; i++){
6958 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
6959 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
6960 endcapassemblymatrix[1][j+2]);
6961 }
6962 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
6963 }
6964 /////////////////////////////////////////////////////////////
6965 // Deallocating memory
6966 /////////////////////////////////////////////////////////////
6967 for(Int_t i=0; i<klayernumber; i++){
6968 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
6969 delete endcapassemblyrot[i][j];
6970 }
7b208ef4 6971 delete [] endcapassemblyrot[i];
9b0c60ab 6972 delete endcapassemblymatrix[i][0];
6973 delete endcapassemblymatrix[i][1];
6974 }
6975 /////////////////////////////////////////////////////////////
6976 }
6977 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
6978 /////////////////////////////////////////////////////////////
6979 // Setting End Cap Support + End Cap Assembly of Layer 5.
6980 /////////////////////////////////////////////////////////////
6981 if (! moth) {
160835d5 6982 AliError("Can't insert end cap support of layer5, mother is null!\n");
9b0c60ab 6983 return;
6984 };
e5bf64ae 6985 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 6986 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
6987 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
6988 fgkEndCapSupportCenterLay5ITSPosition
6989 + fgkEndCapSupportCenterLay5Position
6990 - fgkEndCapSideCoverLength[2]);
6991 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
6992 fgkEndCapSideCoverLength[2]
6993 - fgkEndCapSupportCenterLay5Position
6994 - fgkEndCapSupportCenterLay5ITSPosition);
6995 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
6996 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
6997 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
6998 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
6999 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7000 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7001 /////////////////////////////////////////////////////////////
7002 // Deallocating memory
7003 /////////////////////////////////////////////////////////////
7004 delete endcapsupportsystemrot;
7005 delete endcapsupportsystemITSCentertrans[1];
7006 }
7007 /////////////////////////////////////////////////////////////
7008 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7009 /////////////////////////////////////////////////////////////
7010 // Setting End Cap Support + End Cap Assembly of Layer 6.
7011 /////////////////////////////////////////////////////////////
7012 if (! moth) {
160835d5 7013 AliError("Can't insert end cap support of layer6, mother is null!\n");
9b0c60ab 7014 return;
7015 };
e5bf64ae 7016 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7017 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7018 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7019 fgkEndCapSupportCenterLay6ITSPosition
7020 + fgkEndCapSupportCenterLay6Position
7021 - fgkEndCapSideCoverLength[2]);
7022 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7023 fgkEndCapSideCoverLength[2]
7024 - fgkEndCapSupportCenterLay6Position
7025 - fgkEndCapSupportCenterLay6ITSPosition);
7026 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7027 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7028 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7029 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7030 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7031 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7032 /////////////////////////////////////////////////////////////
7033 // Deallocating memory
7034 /////////////////////////////////////////////////////////////
7035 delete endcapsupportsystemrot;
7036 delete endcapsupportsystemITSCentertrans[1];
7037 }
7038 ////////////////////////////////////////////////////////////////////////////////
7039 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7040 /////////////////////////////////////////////////////////////
7041 // Setting Ladder Support of Layer 5.
7042 /////////////////////////////////////////////////////////////
7043 if (! moth) {
160835d5 7044 AliError("Can't insert ladder lupport of layer5, mother is null!\n");
9b0c60ab 7045 return;
7046 };
7047 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7048 fMotherVol = moth;
7049 TGeoTranslation* centerITSRingSupportLay5trans[2];
7050 for(Int_t i=0; i<2; i++){
7051 centerITSRingSupportLay5trans[i] =
7052 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7053 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7054 }
7055 }
7056 ////////////////////////////////////////////////////////////////////////////////
7057 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7058 /////////////////////////////////////////////////////////////
7059 // Setting Ladder Support of Layer 6.
7060 /////////////////////////////////////////////////////////////
7061 if (! moth) {
160835d5 7062 AliError("Can't insert ladder lupport of layer6, mother is null!\n");
9b0c60ab 7063 return;
7064 };
7065 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7066 fMotherVol = moth;
7067 TGeoTranslation* centerITSRingSupportLay6trans[2];
7068 for(Int_t i=0; i<2; i++){
7069 centerITSRingSupportLay6trans[i] =
7070 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7071 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7072 }
7073 }
7074 ////////////////////////////////////////////////////////////////////////////////
47f8de53 7075 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7076 /////////////////////////////////////////////////////////////
7077 // Setting Ladder Support of Layer 6.
7078 /////////////////////////////////////////////////////////////
7079 if (! moth) {
160835d5 7080 AliError("Can't insert SSD Cone, mother is null!\n");
47f8de53 7081 return;
7082 };
7083 if(!fSSDCone) SetSSDCone();
7084 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7085 + fgkSSDCentralAL3SupportLength);
7086 moth->AddNode(fSSDCone,1,ssdconetrans);
7087}
7088 ////////////////////////////////////////////////////////////////////////////////
7089 void AliITSv11GeometrySSD::SetSSDCone(){
7090 /////////////////////////////////////////////////////////////
7091 // Method generating SSDCone
7092 /////////////////////////////////////////////////////////////
7093 if(!fCreateMaterials) CreateMaterials();
7094 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7095 Double_t ssdpconesectionradiusmax[16];
7096 Double_t ssdpconesectionradiusmin[16];
7097 Double_t ssdpconezsection[16];
7098 TGeoPcon* ssdpconelittleholeshape[8];
7099 TGeoVolume* ssdpconelittlehole[8];
7100 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7101 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7102 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7103 / SinD(fgkSSDPConeAngle)
7104 + ssdpconesectionradiusmin[0];
7105 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7106 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7107 / SinD(fgkSSDPConeAngle);
7108 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7109 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7110 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7111 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7112 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7113 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7114 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7115 ssdpconelittlehole[0]->SetLineColor(4);
7116 /////////////////////////////////////////////////////////////
7117 ssdpconezsection[2] = ssdpconezsection[1];
7118 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7119 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7120 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7121 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7122 / SinD(fgkSSDPConeAngle);
7123 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7124 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7125 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7126 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7127 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7128 * TMath::RadToDeg();
7129 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7130 60.-ssdpconelittleholeangle,2);
7131 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7132 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7133 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7134 ssdpconelittlehole[1]->SetLineColor(4);
7135 TGeoRotation* ssdconelittleholerot[6];
7136 for(Int_t i=0; i<6; i++){
7137 ssdconelittleholerot[i] = new TGeoRotation();
7138 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7139 }
7140 /////////////////////////////////////////////////////////////
7141 ssdpconezsection[4] = ssdpconezsection[3];
7142 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7143 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7144 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7145 * CosD(fgkSSDPConeAngle)
7146 / SinD(fgkSSDPConeAngle);
7147 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7148 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7149 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7150 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7151 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7152 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7153 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7154 ssdpconelittlehole[2]->SetLineColor(4);
7155 ///////////////////////////////////////////////////
7156 ssdpconezsection[6] = ssdpconezsection[5];
7157 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7158 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7159 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7160 -ssdpconezsection[0]
7161 * CosD(fgkSSDPConeAngle)
7162 / SinD(fgkSSDPConeAngle);
7163 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7164 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7165 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7166 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7167 * TMath::RadToDeg();
7168 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7169 45.-ssdpconemiddleholeangle,2);
7170 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7171 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7172 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7173 ssdpconelittlehole[3]->SetLineColor(4);
7174 TGeoRotation* ssdconemiddleholerot[8];
7175 for(Int_t i=0; i<8; i++){
7176 ssdconemiddleholerot[i] = new TGeoRotation();
7177 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7178 }
7179 /////////////////////////////////////////////////////////////
7180 ssdpconezsection[8] = ssdpconezsection[7];
7181 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7182 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7183 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7184 * CosD(fgkSSDPConeAngle)
7185 / SinD(fgkSSDPConeAngle);
7186 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7187 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7188 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7189 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7190 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7191 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7192 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7193 ssdpconelittlehole[4]->SetLineColor(4);
7194 /////////////////////////////////////////////////////////////
7195 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7196 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7197 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7198 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7199 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7200 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7201 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7202 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7203 * TMath::RadToDeg();
7204 ssdpconezsection[10] = ssdpconezsection[9];
7205 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7206 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7207 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7208 * CosD(fgkSSDPConeAngle)
7209 / SinD(fgkSSDPConeAngle);
7210 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7211 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7212 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7213 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7214 ssdpconetrapezoidsectionangle,2);
7215 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7216 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7217 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7218 ssdpconelittlehole[5]->SetLineColor(4);
7219 TGeoRotation* ssdconeupradiusrot[8];
7220 for(Int_t i=0; i<8; i++){
7221 ssdconeupradiusrot[i] = new TGeoRotation();
7222 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7223 }
7224 /////////////////////////////////////////////////////////////
7225 ssdpconezsection[12] = ssdpconezsection[11];
7226 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7227 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7228 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7229 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7230 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7231 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7232 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7233 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7234 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7235 ssdpconelittlehole[6]->SetLineColor(4);
7236 /////////////////////////////////////////////////////////////
7237 ssdpconezsection[14] = 0.0;
7238 ssdpconezsection[15] = ssdpconezsection[0];
7239 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7240 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7241 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7242 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7243 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7244 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7245 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7246 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7247 ssdpconelittlehole[7]->SetLineColor(4);
7248 /////////////////////////////////////////////////////////////
7249 TGeoTube* ssdtubeconeshape[2];
7250 TGeoVolume* ssdtubecone[2];
7251 TGeoTranslation* ssdtubeconetrans[2];
7252 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7253 fgkSSDPConeExternalRadius,
7254 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7255 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7256 0.5*ssdpconezsection[0]);
7257 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7258 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7259 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7260 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7261 + ssdpconezsection[13]);
7262 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7263 ssdtubecone[0]->SetLineColor(4);
7264 ssdtubecone[1]->SetLineColor(4);
7265 /////////////////////////////////////////////////////////////
7266 // Mother Volume Container
7267 /////////////////////////////////////////////////////////////
7268 Double_t ssdconemotherradiusmin[8];
7269 Double_t ssdconemotherradiusmax[8];
7270 Double_t ssdconemothersection[8];
7271 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7272 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7273 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7274 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7275 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7276 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7277 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7278 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7279 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7280 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7281 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7282 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7283 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7284 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7285 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7286 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7287 ssdconemothersection[0] = 0.0;
7288 ssdconemothersection[1] = ssdpconezsection[0];
7289 ssdconemothersection[2] = ssdpconezsection[0];
7290 ssdconemothersection[3] = ssdpconezsection[11];
7291 ssdconemothersection[4] = ssdpconezsection[11];
7292 ssdconemothersection[5] = ssdpconezsection[13];
7293 ssdconemothersection[6] = ssdpconezsection[13];
7294 ssdconemothersection[7] = fgkSSDPConeLength;
7295 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7296 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7297 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7298 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7299 /////////////////////////////////////////////////////////////
7300 //Placing the Volumes into Mother
7301 /////////////////////////////////////////////////////////////
7302 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7303 for(Int_t i=0; i<6; i++){
7304 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7305 }
7306 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7307 for(Int_t i=0; i<8; i++){
7308 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7309 }
7310 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7311 for(Int_t i=0; i<8; i++){
7312 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7313 }
7314 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7315 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7316 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7317 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7318 /////////////////////////////////////////////////////////////
7319 // ITS General Support
7320 /////////////////////////////////////////////////////////////
7321 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7322 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7323 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7324 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7325 - fgkSSDCentralAL3SupportLength);
7326 ssdcentralsupport->SetLineColor(4);
7327 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7328 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7329 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7330 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7331 TGeoTranslation* ssdcentralal3supportrans[3];
7332 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7333 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7334 - 1.25*fgkSSDCentralAL3SupportLength);
7335 ssdcentralal3support->SetLineColor(4);
7336 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7337 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7338 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7339 Double_t ssdpconcentralradiusmin[2];
7340 Double_t ssdpconcentralradiusmax[2];
7341 Double_t ssdpconcentralsection[2];
7342 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7343 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7344 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7345 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7346 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7347 ssdpconcentralsection[1] = 0.;
7348 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7349 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7350 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7351 ssdpconcentralal3->SetLineColor(4);
7352 fSSDCone->AddNode(ssdpconcentralal3,1);
7353 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7354 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7355 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7356 -2.*fgkSSDCentralAL3SupportLength);
7357 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7358 *ssdcentralal3supportrot);
7359 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7360 TGeoRotation* ssdconemotherot = new TGeoRotation();
7361 ssdconemotherot->SetAngles(90.,180.,-90.);
7362 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7363 -2.*fgkSSDCentralAL3SupportLength);
7364 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7365 fSSDCone->AddNode(ssdconemother,1);
7366 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7367 /////////////////////////////////////////////////////////////
7368 // Deallocating memory
7369 /////////////////////////////////////////////////////////////
7370 delete ssdcentralal3supportrot;
7371 delete ssdcentralal3supportrans[2];
7372 delete ssdconemotherot;
7373 delete ssdconemothertrans;
7374 /////////////////////////////////////////////////////////////
7375 }
fcfbdd23 7376 ////////////////////////////////////////////////////////////////////////////////
7377 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7378 /////////////////////////////////////////////////////////////
7379 // Setting SSD Cables
7380 /////////////////////////////////////////////////////////////
7381 if (! moth) {
160835d5 7382 AliError("Can't insert SSD Cables, mother is null!\n");
fcfbdd23 7383 return;
7384 };
7385 TGeoVolume* ssdcables = SetSSDCables();
7386 moth->AddNode(ssdcables,1);
7387}
47f8de53 7388 ////////////////////////////////////////////////////////////////////////////////
7389 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
f7cd318e 7390 /////////////////////////////////////////////////////////////
7391 // Method generating SSDCables
7392 /////////////////////////////////////////////////////////////
7393
7394 /////////////////////////////////////////////////////////////////////////////////
7395 // SSD Cables Parameters (lengths are in mm and angles in degrees)
7396 /////////////////////////////////////////////////////////////////////////////////
7397
7398 const Double_t kSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
7399 const Double_t kSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
7400
7401 // Cable thickness for rings at outer Z
7402 // Average: 9/2 = 4.5 cables per quadrant
7403 // Ideally 1/16 * 38(34) cables, but take factor to (1/8) to accomodate kinks and loops (there are only 2 different cable lengths); 21 mm^2 Cu each
7404
7405 const Double_t kSSDCablesLay5RingArea = 21.*34./8.*fgkmm*fgkmm; // to be fixed in order to reproduce material budget
7406 const Double_t kSSDCablesLay6RingArea = 21.*38./8.*fgkmm*fgkmm; // to be fixed in order to reproduce material budget
7407
7408
7409 const Double_t kSSDCablesHeight = 3.2*fgkmm; // 3.2 mm*13 cm width = 18 cables, 185g/m each Add fudge factor of 2 to get to ~25 kg measured
7410
7411 const Double_t kSSDCableAngle = 22.5;
7412 // MvL: remove water?
7413 const Double_t kSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm; // to be fixed in order to reproduce material budget
7414 const Double_t kSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
7415 const Double_t kSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
7416 const Double_t kSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
7417 const Double_t kSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
7418 const Double_t kSSDPatchPanel2RB26Radius = 451.3*fgkmm;
7419 const Double_t kSSDPatchPanel2RB24Radius = 451.3*fgkmm;
7420 const Double_t kSSDPatchPanelHeight = 87.5*fgkmm;
7421
7422 // SSD Layer 5 Cables
7423 //////////////////////////////////////////////////////////////////////////////////////////////////
7424 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7425 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
7426 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
7427 //////////////////////////////////////////////////////////////////////////////////////////////////
7428 // Printf(Form("Cable ring: rad min: %g length %g thick %g", ssdcableslay5rigthsideradiusmin, ssdcablelay5rightsidelength, kSSDCablesLay5RingArea/ssdcablelay5rightsidelength));
7429
7430
7431
47f8de53 7432 ////////////////////////////////////
7433 // Double_t cablescapacity[20];
7434 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7435 ////////////////////////////////////
f7cd318e 7436 //ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
47f8de53 7437 ////////////////////////////////////
7438 // TGeoPCone Volumes
7439 ///////////////////////////////////
7440 TGeoPcon* ssdcableslay5pconshape[3];
7441 TGeoVolume* ssdcableslay5pcon[3];
7442 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7443 Double_t ssdcableslay5pconzsection[6];
7444 Double_t ssdcableslay5pconrmin[6];
7445 Double_t ssdcableslay5pconrmax[6];
f7cd318e 7446 ssdcableslay5pconrmin[0] = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
47f8de53 7447 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
f7cd318e 7448
47f8de53 7449 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
f7cd318e 7450 + fgkEndCapSupportCenterLay5Position;
7451 //+ 2.*ssdcablelay5rightsidelength; // removing this generates overlap with the water ring
7452 // Keeping it generates overlap with the cones...
7453 // SSDCables/SSDCableLay5RightSideWaterTube_2 ovlp=0.0939792
47f8de53 7454 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7455 + fgkSSDCentralAL3SupportLength
7456 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7457 * TanD(fgkSSDPConeAngle);
f7cd318e 7458 Double_t dz = ssdcableslay5pconzsection[1]-ssdcableslay5pconzsection[0];
7459 Double_t pconethickness = kSSDCablesLay5RingArea/TMath::Abs(dz);
7460 ssdcableslay5pconrmax[0] = ssdcableslay5pconrmin[0]+pconethickness;
7461 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+pconethickness;
7462 //Printf(Form("pcone: r1 %g r2 %g z1 %g z2 %g thickness %g", ssdcableslay5pconrmax[0], ssdcableslay5pconrmax[1],
7463 // ssdcableslay5pconzsection[0],ssdcableslay5pconzsection[1],pconethickness));
7464
47f8de53 7465 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7466 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7467 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7468 ssdcableslay5pconshape[0],fSSDCopper);
7469 ssdcableslay5pcon[0]->SetLineColor(9);
7470 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
f7cd318e 7471
7472 Double_t totvol = ssdcableslay5pcon[0]->Capacity();
7473 // Printf(Form("Cables, lay5, pCone,volume: %g", ssdcableslay5pcon[0]->Capacity()));
47f8de53 7474////////////////////////////////////
7475// cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7476////////////////////////////////////
f7cd318e 7477
7478 //
7479 // PCon 2 and 3 are cables going through/towards holes in supports
7480 //
47f8de53 7481 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7482 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7483 + fgkSSDCentralAL3SupportLength
7484 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7485 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7486 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7487 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7488 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
f7cd318e 7489 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7490 ssdcableangle,2);
7491 // Printf(Form("PCon2, phi %g dphi %g ",90.0-kSSDCableAngle-0.5*ssdcableangle, ssdcableangle));
47f8de53 7492 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
f7cd318e 7493 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
47f8de53 7494 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7495 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7496 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
f7cd318e 7497 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3] + kSSDCablesHeight;
47f8de53 7498 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7499 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7500 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7501 ssdcableslay5pcon[1]->SetLineColor(9);
7502 ////////////////////////////////////
f7cd318e 7503 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7504 ssdcableangle,2);
7505 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7506 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7507 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7508 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7509 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7510 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7511 * TanD(fgkSSDPConeAngle)
7512 + 0.5*fgkSSDCentralSupportLength
7513 + fgkSSDCentralAL3SupportLength;
7514 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7515 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7516 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7517 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7518 ssdcableslay5pcon[2]->SetLineColor(9);
7519////////////////////////////////////
7520 TGeoRotation* ssdcableslay5pconrot[4];
7521 for(Int_t i=0; i<4; i++){
7522 ssdcableslay5pconrot[i] = new TGeoRotation();
7523 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7524 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7525 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
f7cd318e 7526 // Printf(Form("Pcon2, Pcon3, vol %g %g",ssdcableslay5pcon[1]->Capacity(),ssdcableslay5pcon[2]->Capacity()));
7527 totvol += ssdcableslay5pcon[1]->Capacity()+ssdcableslay5pcon[2]->Capacity();
47f8de53 7528 }
7529 ////////////////////////////////////
7530 //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7531 //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7532 ////////////////////////////////////
7533 // Positioning Left SSD Cables Part
7534 ////////////////////////////////////
47f8de53 7535 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7536 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7537 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7538 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7539 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7540 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7541 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7542 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7543 }
7544 ////////////////////////////////////
7545 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7546 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7547 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7548 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7549 /////////////////////////////////////////////////////////////
7550 // Water Tubes Layer 5
7551 /////////////////////////
f7cd318e 7552 /* Remove ring; could be replaced with a PCone next to/on top of the cables
7553
7554 //
7555 // MvL: Remove ring; put everything in PCone
7556 //
7557 // Need to keep dimensions for water ring...
7558
7559 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7560
7561 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
7562 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7563 - fgkSSDLowerPConeRadius)
7564 * TanD(fgkSSDPConeAngle);
7565 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7566 + fgkEndCapSupportCenterLay5Position
7567 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7568 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7569 - ssdcableslay5startconedistance;
7570 ssdcablelay5rightsidelength *= ssdcablesfactor;
7571 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+kSSDCablesLay5RingArea/ssdcablelay5rightsidelength;
7572
7573
7574 TGeoTranslation* ssdcablelay5rightrans =
7575 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7576 + fgkEndCapSupportCenterLay5Position
7577 + 0.5*ssdcablelay5rightsidelength);
7578
7579 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7580 - 0.5*ssdcablelay5rightsidelength
7581 - fgkEndCapSupportCenterLay5Position
7582 - fgkEndCapSupportCenterLay5ITSPosition);
7583
47f8de53 7584 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7585 ssdcableslay5rightsideradiusmax
f7cd318e 7586 + kSSDCablesLay5RightSideWaterHeight,
47f8de53 7587 0.5*ssdcablelay5rightsidelength);
7588 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7589 ssdcablelay5rightubewatershape,
7590 fSSDCoolingTubeWater);
7591 ssdcablelay5rightwatertube->SetLineColor(7);
7592 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7593 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
f7cd318e 7594 */
47f8de53 7595 ////////////////////////////////////
7596 // TGeoPCone Water Volumes Layer
7597 ///////////////////////////////////
7598 TGeoPcon* ssdcableslay5pconwatershape[3];
7599 TGeoVolume* ssdcableslay5pconwater[3];
7600 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7601 Double_t ssdcableslay5pconwaterzsection[6];
7602 Double_t ssdcableslay5pcwateronrmin[6];
7603 Double_t ssdcableslay5pconwaterrmax[6];
7604 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7605 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
f7cd318e 7606 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7607 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7608 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
f7cd318e 7609 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7610 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7611 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7612 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7613 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7614 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7615 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7616 ssdcableslay5pconwater[0]->SetLineColor(7);
7617 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7618 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7619////////////////////////////////////
7620 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7621 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
f7cd318e 7622 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7623 ssdcableangle,2);
7624 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7625 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
f7cd318e 7626 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7627 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7628 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
f7cd318e 7629 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7630 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7631 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7632 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7633 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7634 ssdcableslay5pconwater[1]->SetLineColor(7);
7635////////////////////////////////////
f7cd318e 7636 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7637 ssdcableangle,2);
7638 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7639 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
f7cd318e 7640 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7641 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7642 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
f7cd318e 7643 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7644 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7645 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7646 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7647 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7648 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7649 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7650 ssdcableslay5pconwater[2]->SetLineColor(7);
7651////////////////////////////////////
7652 TGeoRotation* ssdcableslay5pconwaterot[4];
7653 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7654 for(Int_t i=0; i<4; i++){
7655 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7656 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7657 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7658 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7659 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7660 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7661 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7662 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7663 }
7664 /////////////////////////
7665 // SSD Layer 6 Cables
7666 /////////////////////////
f7cd318e 7667 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+kSSDCablesLay6TubeRadiusMin;
7668 Double_t ssdcablelay6rightsidelength = 2.; // cm was 2.*ssdcablelay5rightsidelength;
7669 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+kSSDCablesLay6RingArea/ssdcablelay6rightsidelength;
7670 // Printf(Form("Lay 6 cables, length %g, radius %g, thickness %g", ssdcablelay6rightsidelength, ssdcableslay6rigthsideradiusmin, kSSDCablesLay6RingArea/ssdcablelay6rightsidelength));
47f8de53 7671 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7672 ssdcableslay6rightsideradiusmax,
7673 0.5*ssdcablelay6rightsidelength);
7674 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7675 ssdcablelay6rightubeshape,
7676 fSSDCopper);
7677 ssdcablelay6righttube->SetLineColor(9);
7678 TGeoTranslation* ssdcablelay6rightrans =
7679 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7680 + fgkEndCapSupportCenterLay6Position
7681 + 0.5*ssdcablelay6rightsidelength);
7682 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7683 - 0.5*ssdcablelay6rightsidelength
7684 - fgkEndCapSupportCenterLay6Position
7685 - fgkEndCapSupportCenterLay6ITSPosition);
7686 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7687 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
f7cd318e 7688 // Printf(Form("Cables; ring layer 6, volume: %g",ssdcablelay6rightubeshape->Capacity()));
7689 totvol += ssdcablelay6rightubeshape->Capacity();
47f8de53 7690 ////////////////////////////////////
7691 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7692 ////////////////////////////////////
f7cd318e 7693 // MvL: PCon is part of connection to patch panels;
7694 // removed since current volume is too thick; now absorbed in rings+connections
7695 /*
7696 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7697 ssdcableangle,2);
7698 TGeoVolume* ssdcableslay6pcon;
7699 Double_t ssdcableslay6pconrmin[2];
7700 Double_t ssdcableslay6pconrmax[2];
7701 Double_t ssdcableslay6pconzsection[2];
7702 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7703 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7704 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7705 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7706 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7707 + fgkEndCapSupportCenterLay6Position
7708 + ssdcablelay6rightsidelength;
7709 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7710 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7711 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
f7cd318e 7712
47f8de53 7713 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7714 ssdcableslay6pconshape,fSSDCopper);
7715 ssdcableslay6pcon->SetLineColor(9);
7716 for(Int_t i=0; i<4; i++){
7717 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7718 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7719 }
f7cd318e 7720 */
47f8de53 7721 ////////////////////////////////////
7722 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7723 /////////////////////////
7724 // Water Tubes Layer 6
7725 /////////////////////////
7726 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7727 ssdcableslay6rightsideradiusmax
f7cd318e 7728 + kSSDCablesLay5RightSideWaterHeight,
47f8de53 7729 0.5*ssdcablelay6rightsidelength);
7730 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7731 ssdcablelay6righwatertubeshape,
7732 fSSDCoolingTubeWater);
7733 ssdcablelay6rightwatertube->SetLineColor(7);
7734 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7735 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
f7cd318e 7736 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7737 ssdcableangle,2);
7738 TGeoVolume* ssdcableslay6waterpcon;
7739 Double_t ssdcableslay6waterpconrmin[2];
7740 Double_t ssdcableslay6waterpconrmax[2];
7741 Double_t ssdcableslay6waterpconzsection[2];
7742 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7743 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
f7cd318e 7744 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7745 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7746 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7747 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7748 + fgkEndCapSupportCenterLay6Position
7749 + ssdcablelay6rightsidelength;
7750 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7751 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7752 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7753 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7754 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7755 ssdcableslay6waterpcon->SetLineColor(7);
7756 TGeoRotation* ssdcableslay6pconwaterot[4];
7757 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7758 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7759 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7760 for(Int_t i=0; i<4; i++){
7761 ssdcableslay6pconwaterot[i] = new TGeoRotation();
7762 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7763 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7764 * (*ssdcableslay6pconwaterot[i]));
7765 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7766 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7767 }
7768 ////////////////////////////////////////
7769 // From ITS Ring to Patch Panel3-RB26
7770 ////////////////////////////////////////
7771 Double_t ssdcablepatchpanel3BB26radiusmin[2];
7772 Double_t ssdcablepatchpanel3BB26radiusmax[2];
7773 Double_t ssdcablepatchpanel3RB26zsection[2];
f7cd318e 7774 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*kSSDPatchPanelHeight;// +2.8+0.003;//Avoid small overlap with SPDshieldring;
47f8de53 7775 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
f7cd318e 7776 + kSSDCablesHeight;
7777 ssdcablepatchpanel3BB26radiusmin[1] = kSSDPatchPanel2RB26Radius;
47f8de53 7778 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
f7cd318e 7779 + kSSDCablesHeight;
47f8de53 7780 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
f7cd318e 7781 + fgkSSDCentralAL3SupportLength
47f8de53 7782 + fgkSSDPConeZLength[0];
f7cd318e 7783 ssdcablepatchpanel3RB26zsection[1] = kSSDPatchPanel2RB26ITSDistance;
7784 // Printf(Form("RB26 cable length %g",ssdcablepatchpanel3RB26zsection[1]-ssdcablepatchpanel3RB26zsection[0]));
7785 // Printf(Form("Angular range %g",ssdcableangle));
7786
47f8de53 7787 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
f7cd318e 7788 new TGeoPcon(90.0-kSSDCablesPatchPanel2RB26Angle[0]
47f8de53 7789 - 0.5*ssdcableangle,ssdcableangle,2);
7790 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7791 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7792 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7793 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7794 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
85f741d8 7795 TGeoRotation* ssdcablepatchpanel3B26rot[4];
47f8de53 7796 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
67446e8a 7797 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
f7cd318e 7798 ssdcablepatchpanel3B26rot[1]->SetAngles(kSSDCablesPatchPanel2RB26Angle[0]
7799 + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
67446e8a 7800 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
f7cd318e 7801 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0 + kSSDCablesPatchPanel2RB26Angle[0]
7802 + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
47f8de53 7803 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
f7cd318e 7804 // Printf(Form("Cable to patch panels RB26 volume: %g (x4)",ssdcablepatchpanel3RB26pcon->Capacity()));
47f8de53 7805 ////////////////////////////////////
7806 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7807 ////////////////////////////////////////
7808 // ITS Ring Cables RB26 Part
7809 ////////////////////////////////////////
7810 Double_t ssdcableitsring3BB26pconzsection[2];
7811 Double_t ssdcableitsring3BB26pconrmin[2];
7812 Double_t ssdcableitsring3BB26pconrmax[2];
7813 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7814 + fgkSSDCentralAL3SupportLength
7815 + (4.0/5.0)*fgkSSDPConeZLength[0];
7816 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
f7cd318e 7817 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
7818 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0] + 2.5*kSSDCablesHeight; // widths of cable bunch is about half of patch panels; need factor 2.5
7819
47f8de53 7820 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7821 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7822 TGeoPcon* ssdcableitsring3BB26pconshape[4];
f7cd318e 7823 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0 - kSSDCablesPatchPanel2RB26Angle[0]
47f8de53 7824 - 0.5*ssdcableangle,ssdcableangle
f7cd318e 7825 + (kSSDCablesPatchPanel2RB26Angle[0]
7826 - kSSDCableAngle),2);
7827 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0 + kSSDCablesPatchPanel2RB26Angle[1]
47f8de53 7828 - 0.5*ssdcableangle,ssdcableangle
f7cd318e 7829 + 3.0*kSSDCableAngle
7830 - kSSDCablesPatchPanel2RB26Angle[1],2);
7831 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-kSSDCablesPatchPanel2RB26Angle[0]
47f8de53 7832 - 0.5*ssdcableangle,ssdcableangle
f7cd318e 7833 - kSSDCableAngle
7834 + kSSDCablesPatchPanel2RB26Angle[0],2);
7835 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+kSSDCablesPatchPanel2RB26Angle[1]
47f8de53 7836 - 0.5*ssdcableangle,ssdcableangle
f7cd318e 7837 + 3.0*kSSDCableAngle
7838 - kSSDCablesPatchPanel2RB26Angle[1],2);
47f8de53 7839 for(Int_t i=0;i<4;i++)
7840 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7841 ssdcableitsring3BB26pconrmin[j],
7842 ssdcableitsring3BB26pconrmax[j]);
7843 TGeoVolume* ssdcableitsring3BB26pcon[4];
7844 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7845 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7846 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7847 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7848 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7849 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7850 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7851 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7852 for(Int_t i=0;i<4;i++){
7853 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
5ef8864c 7854 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
f7cd318e 7855 //Printf(Form("Cable to patch panels RB26 volume part 2: %g (%d)",ssdcableitsring3BB26pcon[i]->Capacity(),i));
47f8de53 7856}
f7cd318e 7857
47f8de53 7858 ////////////////////////////////////
7859 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7860 // + ssdcableitsring3BB26pconshape[1]->Capacity()
7861 // + ssdcableitsring3BB26pconshape[2]->Capacity()
7862 // + ssdcableitsring3BB26pconshape[3]->Capacity();
7863 ////////////////////////////////////////
7864 // From ITS Ring to Patch Panel2-RB24
7865 ////////////////////////////////////////
7866 Double_t ssdcablepatchpanel3BB24radiusmin[2];
7867 Double_t ssdcablepatchpanel3BB24radiusmax[2];
7868 Double_t ssdcablepatchpanel3RB24zsection[2];
7869 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7870 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
f7cd318e 7871 ssdcablepatchpanel3BB24radiusmin[1] = kSSDPatchPanel2RB24Radius;
47f8de53 7872 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
f7cd318e 7873 + kSSDCablesHeight;
47f8de53 7874 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7875 - fgkSSDCentralAL3SupportLength
7876 - fgkSSDPConeZLength[0];
f7cd318e 7877 ssdcablepatchpanel3RB24zsection[1] = -kSSDPatchPanel2RB24ITSDistance;
7878 //Printf(Form("RB24 cable length %g",ssdcablepatchpanel3RB24zsection[1]-ssdcablepatchpanel3RB24zsection[0]));
47f8de53 7879 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
f7cd318e 7880 new TGeoPcon(90.0-kSSDCablesPatchPanel2RB24Angle[1]
47f8de53 7881 - 0.5*ssdcableangle,ssdcableangle,2);
7882 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7883 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7884 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7885 ssdcablepatchpanel3RB24pconshape,
7886 fSSDCopper);
7887 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
85f741d8 7888 TGeoRotation* ssdcablepatchpanel3B24rot[4];
47f8de53 7889 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
67446e8a 7890 ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
f7cd318e 7891 ssdcablepatchpanel3B24rot[1]->SetAngles(kSSDCablesPatchPanel2RB24Angle[0]
7892 + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
67446e8a 7893 ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
f7cd318e 7894 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+kSSDCablesPatchPanel2RB24Angle[0]
7895 + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
47f8de53 7896 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
f7cd318e 7897 //Printf(Form("Cable to patch panels RB24 volume: %g (x4)",ssdcablepatchpanel3RB24pcon->Capacity()));
47f8de53 7898 ////////////////////////////////////
7899 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7900 ////////////////////////////////////////
7901 // ITS Ring Cables RB24 Part
7902 ////////////////////////////////////////
7903 Double_t ssdcableitsring3BB24pconzsection[2];
7904 Double_t ssdcableitsring3BB24pconrmin[2];
7905 Double_t ssdcableitsring3BB24pconrmax[2];
7906 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7907 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
f7cd318e 7908 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
7909 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0] + 2.5*kSSDCablesHeight; // Cable bunch width smaller; make it thicker
7910
47f8de53 7911 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
7912 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
7913 TGeoPcon* ssdcableitsring3BB24pconshape[4];
f7cd318e 7914 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7915 + (90.0-kSSDCablesPatchPanel2RB24Angle[1]
7916 - kSSDCableAngle),2);
7917 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+kSSDCableAngle-0.5*ssdcableangle,
7918 ssdcableangle-kSSDCableAngle
7919 + kSSDCablesPatchPanel2RB24Angle[0],2);
7920 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7921 - kSSDCableAngle
7922 + 90.0 - kSSDCablesPatchPanel2RB24Angle[1],2);
7923 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+kSSDCableAngle-0.5*ssdcableangle,
7924 ssdcableangle-kSSDCableAngle
7925 + kSSDCablesPatchPanel2RB24Angle[0],2);
47f8de53 7926 for(Int_t i=0;i<4;i++)
7927 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
7928 ssdcableitsring3BB24pconrmin[j],
7929 ssdcableitsring3BB24pconrmax[j]);
7930 TGeoVolume* ssdcableitsring3BB24pcon[4];
7931 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
7932 ssdcableitsring3BB24pconshape[0],fSSDCopper);
7933 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
7934 ssdcableitsring3BB24pconshape[1],fSSDCopper);
7935 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
7936 ssdcableitsring3BB24pconshape[2],fSSDCopper);
7937 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
7938 ssdcableitsring3BB24pconshape[3],fSSDCopper);
7939 for(Int_t i=0;i<4;i++){
7940 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
5ef8864c 7941 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
f7cd318e 7942 // Printf(Form("Cable to patch panels RB24 (part 2) volume: %g (%d)",ssdcableitsring3BB24pcon[i]->Capacity(),i));
47f8de53 7943}
f7cd318e 7944
47f8de53 7945 ////////////////////////////////////
7946 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
7947 // + ssdcableitsring3BB24pconshape[1]->Capacity()
7948 // + ssdcableitsring3BB24pconshape[2]->Capacity()
7949 // + ssdcableitsring3BB24pconshape[3]->Capacity();
47f8de53 7950
f7cd318e 7951 // MvL: Pcon are connection to patch panels (part of)
7952 // Removed; do not contribute much; put into ring structure
7953 /*
47f8de53 7954 TGeoPcon* ssdcablelay6materialbudgetpconshape =
f7cd318e 7955 new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
47f8de53 7956 TGeoVolume* ssdcablelay6materialbudgetpcon;
7957 Double_t ssdcablelay6materialbudgetpconrmin[2];
7958 Double_t ssdcablelay6materialbudgetpconrmax[2];
7959 Double_t ssdcablelay6materialbudgetpconzsection[2];
7960 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
f7cd318e 7961 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7962 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
f7cd318e 7963 + kSSDCableMaterialBudgetHeight;
47f8de53 7964 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
7965 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
7966 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7967 + fgkEndCapSupportCenterLay6Position
7968 + ssdcablelay6rightsidelength;
7969 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7970 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
7971 ssdcablelay6materialbudgetpconzsection[i],
7972 ssdcablelay6materialbudgetpconrmin[i],
7973 ssdcablelay6materialbudgetpconrmax[i]);
7974 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
7975 ssdcablelay6materialbudgetpconshape,fSSDCopper);
7976 ssdcablelay6materialbudgetpcon->SetLineColor(9);
7977 for(Int_t i=0; i<4; i++){
7978 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
7979 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7980 }
f7cd318e 7981 */
47f8de53 7982////////////////////////////////////
7983 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
7984 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
7985 Double_t ssdcablesvolume = 0.0;
7986 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
7987 std::cout << ssdcablesvolume << std::endl;*/
f7cd318e 7988 // Printf(Form("Total volume (one side; without conn to patch panel): %g",totvol));
47f8de53 7989 return ssdcablesmother;
7990 }
7991 ////////////////////////////////////////////////////////////////////////////////
277f0a14 7992TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3 const * const vertexpos[4] , const Double_t* width,
b671cde1 7993 Double_t height, const char* shapename, Int_t isign) const{
44285dfa 7994 /////////////////////////////////////////////////////////////
7995 // Method generating an Arb shape
7996 /////////////////////////////////////////////////////////////
7997 const Int_t kvertexnumber = 8;
7998 const Int_t ktransvectnumber = 2;
b671cde1 7999 TVector3 vertex[kvertexnumber];
8000 TVector3 transvector[2];
8001 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
44285dfa 8002 /////////////////////////////////////////////////////////////
d7599219 8003 //Setting the vertices for TGeoArb8
44285dfa 8004 /////////////////////////////////////////////////////////////
b671cde1 8005 vertex[0] = *vertexpos[0];
8006 vertex[1] = *vertexpos[1];
8007 vertex[2] = vertex[1];
8008 vertex[3] = vertex[0];
8009 vertex[4] = *vertexpos[2];
8010 vertex[5] = *vertexpos[3];
8011 vertex[6] = vertex[5];
8012 vertex[7] = vertex[4];
8013
8014 // NB: order of points is clockwise
8015 if (isign < 0) {
8016 vertex[2] -= transvector[0];
8017 vertex[3] -= transvector[0];
8018 vertex[6] -= transvector[1];
8019 vertex[7] -= transvector[1];
8020 }
8021 else {
8022 vertex[0] += transvector[0];
8023 vertex[1] += transvector[0];
8024 vertex[4] += transvector[1];
8025 vertex[5] += transvector[1];
8026 }
8027
44285dfa 8028 /////////////////////////////////////////////////////////////
8029 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
b671cde1 8030 for(Int_t i = 0; i<kvertexnumber;i++) {
8031 arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
8032 }
8033
44285dfa 8034 return arbshape;
d7599219 8035}
bf210566 8036///////////////////////////////////////////////////////////////////////////////
8037TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8038 Double_t rmax, Int_t nedges, Double_t height){
8039 /////////////////////////////////////////////////////////////
8040 // Method generating Arc shape
8041 /////////////////////////////////////////////////////////////
8042 const Int_t kvertexnumber = 2*nedges+2;
8043 TGeoXtru* arcshape = new TGeoXtru(2);
8044 TVector3** vertexposition[2];
8045 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8046 Double_t angle = 0.;
8047 for(Int_t i=0; i<nedges+1; i++){
8048 angle = 90.+0.5*phi-i*(phi/nedges);
c2aad3ae 8049 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle),0);
8050 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle),0);
bf210566 8051 }
8052 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8053 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8054 for(Int_t i=0; i<kvertexnumber; i++){
8055 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8056 yvertexpoints[i] = vertexposition[0][i]->Y();
8057 }
8058 else if(i>=1&&i<nedges+2)
8059 {
8060 xvertexpoints[i] = vertexposition[1][i-1]->X();
8061 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8062 }
8063 else
8064 {
8065 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8066 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8067 }
8068 }
8069 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8070 arcshape->DefineSection(0,-0.5*height);
8071 arcshape->DefineSection(1,0.5*height);
44285dfa 8072 /////////////////////////////////////////////////////////////
bf210566 8073 // Deallocating memory
44285dfa 8074 /////////////////////////////////////////////////////////////
bf210566 8075 for(Int_t i=0; i<2; i++){
8076 for(Int_t j=0; j<nedges+1; j++)
8077 delete vertexposition[i][j];
8078 delete [] vertexposition[i];
8079 }
8080 delete [] xvertexpoints;
8081 delete [] yvertexpoints;
8082 /////////////////////////////////////////////////////////////
8083 return arcshape;
d7599219 8084}
8085////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8086TGeoShape* AliITSv11GeometrySSD::GetScrewShape(const Double_t* radius,const Int_t* edgesnumber,const Double_t* section) const {
9b0c60ab 8087 ///////////////////////////////////////////////////////////////////////
8088 // Method Generating the Screw Shape
8089 // radius[0]: outer radius
8090 // radius[1]: inner radius
8091 // edgesnumber[0]: outer number of edges
8092 // edgesnumber[1]: inner number of edges
8093 // section[0]: lower section position
8094 // section[1]: higher section position
8095 ///////////////////////////////////////////////////////////////////////
8096 Double_t outradius = radius[0];
8097 Double_t inradius = radius[1];
8098 Int_t outvertexnumber = edgesnumber[0];
8099 Int_t invertexnumber = edgesnumber[1];
851c0ce3 8100 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8101 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8102 for(Int_t i=0; i<outvertexnumber; i++){
9b0c60ab 8103 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8104 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8105 }
851c0ce3 8106 for(Int_t i=0; i<invertexnumber; i++){
8107 xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8108 yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
9b0c60ab 8109 }
851c0ce3 8110 TGeoXtru* screwshapeout = new TGeoXtru(2);
8111 screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8112 screwshapeout->DefineSection(0,section[0]);
8113 screwshapeout->DefineSection(1,section[1]);
8114 TGeoXtru* screwshapein = new TGeoXtru(2);
8115 screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8116 screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8117 screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8118 TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8119 TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8120
9b0c60ab 8121 delete [] xscrewvertex;
8122 delete [] yscrewvertex;
8123 return screwshape;
8124}
8125////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8126TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, const Double_t *section) const {
9b0c60ab 8127 ///////////////////////////////////////////////////////////////////////
8128 // Method Generating the Hole Shape
8129 // radius of the Hole
8130 // nedges: number of edges to approximate the circle
8131 ///////////////////////////////////////////////////////////////////////
851c0ce3 8132 Double_t* xholevertex = new Double_t[nedges];
8133 Double_t* yholevertex = new Double_t[nedges];
8134 Double_t z = 0.5*(section[0]+section[1]);
8135 Double_t dz = 0.5*(section[1]-section[0]);
8136 TGeoTranslation *tr = 0;
8137 if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8138 tr = new TGeoTranslation(0.,0.,z);
8139 tr->RegisterYourself();
8140 }
8141 TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8142 for(Int_t i=0; i<nedges; i++){
8143 xholevertex[i] = radius*CosD(i*360./nedges);
8144 yholevertex[i] = radius*SinD(i*360./nedges);
9b0c60ab 8145 }
851c0ce3 8146 TGeoXtru* holeshapeout = new TGeoXtru(2);
8147 holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8148 holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8149 holeshapeout->DefineSection(1,section[1]+0.01);
8150 TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8151 TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8152
9b0c60ab 8153 delete [] xholevertex;
8154 delete [] yholevertex;
8155 return holeshape;
8156}
8157////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8158TVector3* AliITSv11GeometrySSD::GetReflection(const TVector3* vector,const Double_t* param) const{
44285dfa 8159 /////////////////////////////////////////////////////////////
8160 // Given an axis specified by param, it gives the reflection of the point
8161 // respect to the axis
8162 /////////////////////////////////////////////////////////////
8163 TVector3* n = new TVector3(param[0],param[1],param[2]);
8164 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8165 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 8166 /////////////////////////////////////////////////////////////
8167 // Deallocating memory
8168 /////////////////////////////////////////////////////////////
8169 delete n;
8170 /////////////////////////////////////////////////////////////
44285dfa 8171 return reflectedvector;
d7599219 8172}
8173////////////////////////////////////////////////////////////////////////////////
f510fd70 8174TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(const TGeoHMatrix* ct,
d7599219 8175 Double_t dx,
8176 Double_t dy,
8177 Double_t dz) const{
44285dfa 8178 /////////////////////////////////////////////////////////////
d7599219 8179 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 8180 /////////////////////////////////////////////////////////////
bf210566 8181 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8182 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 8183 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 8184 hmatrix->SetTranslation(newvect);
8185 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8186 delete hmatrix;
8187 return matrix;
d7599219 8188}
8189////////////////////////////////////////////////////////////////////////////////
d7599219 8190TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 8191 /////////////////////////////////////////////////////////////
8192 // Method returning the Medium type
8193 /////////////////////////////////////////////////////////////
a3f8715e 8194 char ch[100];
045be90c 8195 snprintf(ch,100, "ITS_%s",mediumName);
d7599219 8196 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8197 if (! medium)
160835d5 8198 AliError(Form("medium %s not found !\n", mediumName));
d7599219 8199 return medium;
8200}
8201////////////////////////////////////////////////////////////////////////////////
d7599219 8202void AliITSv11GeometrySSD::CreateMaterials(){
8203///////////////////////////////////
8204// This part has to be modified
8205///////////////////////////////////
8206 ///////////////////////////////////
8207 // Silicon for Sensor
8208 ///////////////////////////////////
bf210566 8209 fSSDSensorMedium = GetMedium("SI$");
d7599219 8210 ///////////////////////////////////
8211 // Silicon Mixture for Sensor
8212 ///////////////////////////////////
44285dfa 8213 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8214 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 8215 ///////////////////////////////////
8216 // Stiffener Components Materials
8217 ///////////////////////////////////
bf210566 8218 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 8219 ///////////////////////////
8220 // Stiffener Connectors
8221 ///////////////////////////
bf210566 8222 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 8223 ////////////////////////////////
8224 // Stiffener 0603-1812 Capacitor
8225 ////////////////////////////////
bf210566 8226 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8227 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
78e34526 8228 fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$");
d7599219 8229 ///////////////////////////
8230 // Stiffener Hybrid Wire
8231 ///////////////////////////
bf210566 8232 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 8233 ///////////////////////////
8234 // Al for Cooling Block
8235 ///////////////////////////
bf210566 8236 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 8237 //////////////////////////////////////////////////////
8238 // Kapton and Al for Chip Cable Flex and Ladder Cables
8239 //////////////////////////////////////////////////////
bf210566 8240 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8241 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8242 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8243 fSSDAlTraceFlexMedium = GetMedium("AL$");
8244 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8245 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 8246 /////////////////////////////////////////////////////////////////
8247 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8248 //////////////////////////////////////////////////////////////////
44285dfa 8249 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 8250 /////////////////////////////////////////////////////////////////
8251 // G10 for Detector Leg, TubeHolder
8252 //////////////////////////////////////////////////////////////////
44285dfa 8253 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8254 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8255 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8256 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 8257 /////////////////////////////////////////////////////////////////
8258 // Water and Phynox for Cooling Tube
8259 //////////////////////////////////////////////////////////////////
bf210566 8260 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 8261 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 8262 /////////////////////////////////////////////////////////////////////
9b0c60ab 8263 // Material for Support Rings
8264 /////////////////////////////////////////////////////////////////////
8265 fSSDSupportRingAl = GetMedium("AL$");
47f8de53 8266 fSSDRohaCellCone = GetMedium("ROHACELL$");
9b0c60ab 8267 /////////////////////////////////////////////////////////////////////
bf210566 8268 fSSDAir = GetMedium("SDD AIR$");
47f8de53 8269 fSSDCopper = GetMedium("COPPER$");
78e34526 8270 fSSDSn = GetMedium("Sn$");
bf210566 8271 fCreateMaterials = kTRUE;
d7599219 8272}
8273/////////////////////////////////////////////////////////////////////
277f0a14 8274