]> 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
Fixes for compilation with Root6
[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 /////////////////////////////////////////////////////////////////////////////
3873 TGeoXtru* laddershape[fgkladdernumber];
3874 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
3875 const Int_t kmothervertexnumber = 8;
3876 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
3877 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
3878 ///////////////////////
3879 // Setting the vertices
3880 ///////////////////////
3881 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
78e34526 3882 * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]);
bf210566 3883 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
0fb26117 3884 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
bf210566 3885 xmothervertex[0][1] = xmothervertex[0][0];
78e34526 3886 ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010
bf210566 3887 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
3888 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
3889 ymothervertex[0][2] = ymothervertex[0][1];
3890 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
3891 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
3892 xmothervertex[0][4] = -xmothervertex[0][3];
3893 ymothervertex[0][4] = ymothervertex[0][3];
3894 xmothervertex[0][5] = -xmothervertex[0][2];
3895 ymothervertex[0][5] = ymothervertex[0][2];
3896 xmothervertex[0][6] = -xmothervertex[0][1];
3897 ymothervertex[0][6] = ymothervertex[0][1];
3898 xmothervertex[0][7] = -xmothervertex[0][0];
3899 ymothervertex[0][7] = ymothervertex[0][0];
3900 for(Int_t i=0; i<kmothervertexnumber; i++){
3901 xmothervertex[1][i] = xmothervertex[0][i];
3902 ymothervertex[1][i] = ymothervertex[0][i];
3903 }
0fb26117 3904///////////////////////////////////////////////////////////////////////////
3905// Disalignement Mother Volume corrections 25/08/08
3906///////////////////////////////////////////////////////////////////////////
160835d5 3907 TGeoXtru* leftladdershape1[fgkladdernumber];
3908 TGeoXtru* leftladdershape2[fgkladdernumber];
0fb26117 3909 TGeoXtru* centersensorladdershape[fgkladdernumber];
160835d5 3910 TGeoXtru* rightladdershape1[fgkladdernumber];
3911 TGeoXtru* rightladdershape2[fgkladdernumber];
bf210566 3912 for(Int_t i=0; i<fgkladdernumber; i++){
160835d5 3913 leftladdershape1[i] = new TGeoXtru(2);
3914 leftladdershape2[i] = new TGeoXtru(2);
3915 centersensorladdershape[i] = new TGeoXtru(2);
3916 rightladdershape1[i] = new TGeoXtru(2);
3917 rightladdershape2[i] = new TGeoXtru(2);
3918 }
0fb26117 3919 //////////////////////////////////////
160835d5 3920 // Setting the names for shapes
0fb26117 3921 //////////////////////////////////////
160835d5 3922 leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
3923 leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
3924 leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
3925 leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
0fb26117 3926 centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
3927 centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
160835d5 3928 rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
3929 rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
3930 rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
3931 rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
0fb26117 3932 //////////////////////////////////////
160835d5 3933 Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
3934 Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
0fb26117 3935 Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
3936 Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
160835d5 3937 Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
3938 Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
3939 for(Int_t i=0; i<fgkladdernumber; i++) {
3940 for(Int_t j=0; j<kmothervertexnumber; j++){
3941 xcentersensorvertex[i][j] = xmothervertex[i][j];
3942 ycentersensorvertex[i][j] = ymothervertex[i][j];
3943 xend1laddervertex[i][j] = xmothervertex[i][j];
3944 yend1laddervertex[i][j] = ymothervertex[i][j];
3945 xend2laddervertex[i][j] = xmothervertex[i][j];
3946 yend2laddervertex[i][j] = ymothervertex[i][j];
3947 }
3948 // Add some space around sensors to accommodate misalignments
3949 xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
3950 xcentersensorvertex[i][1] = xcentersensorvertex[0][0];
3951 xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
3952 xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
3953
3954 ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
3955 ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
3956
3957 // Center Ladder Piece
3958 centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
3959 ycentersensorvertex[i]);
3960 centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3961 + 1.45*fgkSSDMountingBlockWidth);
3962 centersensorladdershape[i]->DefineSection(1, ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
3963 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
3964 - 2.4*fgkSSDMountingBlockWidth);
0fb26117 3965
160835d5 3966 // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
0fb26117 3967
160835d5 3968 // Cuts off first corner (neg x)
3969 xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
3970 xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
3971 // Cuts off last part (pos x)
3972 xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
3973 xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
0fb26117 3974
160835d5 3975 leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3976 yend1laddervertex[i]);
3977 leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
3978 leftladdershape1[i]->DefineSection(1, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3979 - fgkEndLadderMountingBlockPosition[0]);
3980
3981 leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3982 yend2laddervertex[i]);
3983 leftladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3984 - fgkEndLadderMountingBlockPosition[0]);
3985 leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
3986 + 1.45*fgkSSDMountingBlockWidth); // connect to main volume at -1.6725 cm
3987
3988 rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3989 yend1laddervertex[i]);
3990 rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
3991 +fgkEndLadderCarbonFiberLowerJunctionLength[0]
3992 -2.4*fgkSSDMountingBlockWidth);
3993 rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
3994 + fgkEndLadderMountingBlockPosition[1]);
3995
3996 rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3997 yend2laddervertex[i]);
3998 rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
3999 + fgkEndLadderMountingBlockPosition[1]);
4000 rightladdershape2[i]->DefineSection(1, ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4001 + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4002 }
4003 TGeoCompositeShape* laddershapecontainer[2];
4004 laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4005 "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4006 "+Lay5CenterSensorContainer"
4007 "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4008 laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4009 "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4010 "+Lay6CenterSensorContainer"
4011 "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4012 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4013 for(Int_t i=0; i<fgkladdernumber; i++){
4014 fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4015 fladder[i]->SetLineColor(4);
4016 }
bf210566 4017///////////////////////////////////////////////////////////////////////////
4018 if(!fCreateMaterials) CreateMaterials();
4019 if(!fTransformationMatrices) CreateTransformationMatrices();
4020 if(!fBasicObjects) CreateBasicObjects();
4021 SetLadderSegment();
4022 SetEndLadderSegment();
4023 for(Int_t i=0; i<fgkladdernumber; i++){
4024 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4025 //////////////////////////
4026 /// Placing Ladder Segment
4027 //////////////////////////
4028 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4029 fladdersegment[i==0 ? 1 : 0],
4030 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4031 //////////////////////////
4032 /// Placing SSD Sensor
4033 //////////////////////////
ca86fdb4 4034 if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
bf210566 4035 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4036 fssdsensormatrix[i][j]);
4037 }
4038 ///////////////////////////////
4039 /// Placing End Ladder Segment
4040 ///////////////////////////////
160835d5 4041 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
bf210566 4042 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4043 }
d7599219 4044/////////////////////////////////////////////////////////////////////////////
4045/// Placing Ladder Cables
4046/////////////////////////////////////////////////////////////////////////////
bf210566 4047 Int_t sidecablenumber[2][2];
4048 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4049 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4050 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4051 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4052 Double_t carbonfibertomoduleposition[3];
4053 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4054 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4055 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4056 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4057 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4058 - fgkSSDSensorCenterSupportThickness[0]);
4059 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4060 + 0.5*fgkCoolingTubeSupportHeight
4061 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4062 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4063 Double_t ssdendladdercablelength[4];
4064 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4065 + fgkSSDSensorLength
4066 - fgkSSDModuleStiffenerPosition[1]
4067 - fgkSSDStiffenerWidth
4068 - fgkSSDFlexWidth[0]
bf210566 4069 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4070 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4071 + fgkSSDModuleStiffenerPosition[1]
4072 + fgkSSDStiffenerWidth
bf210566 4073 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4074 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4075 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4076 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4077 - kendladdercablecorrection;
44285dfa 4078 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4079 + carbonfibertomoduleposition[1]
d7599219 4080 - fgkSSDModuleStiffenerPosition[1]
4081 - fgkSSDStiffenerWidth)
bf210566 4082 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
78e34526 4083
44285dfa 4084 TList* laddercableassemblylist[4];
4085 const Int_t kendladdercablesnumber = 4;
cd2243fb 4086 TGeoRotation *laddercablerot = new TGeoRotation();
4087 laddercablerot->SetAngles(90.,60.,-90.);
bf210566 4088 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4089 for(Int_t j=0; j<kendladdercablesnumber; j++){
4090 laddercableassemblylist[j] =
4091 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4092 ssdendladdercablelength[j]);
0fb26117 4093 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4094 j<2?1:2,fladdercablematrix[i][j]);
bf210566 4095 }
bf210566 4096}
4097////////////////////////////////////////////////////////////////////////////////
4098void AliITSv11GeometrySSD::SetLayer(){
d7599219 4099////////////////////////////////////////////////////////////////////////////////
bf210566 4100 // Creating Ladder of Layer 5 and Layer 6
4101 /////////////////////////////////////////////////////////////
4102 if(!fCreateMaterials) CreateMaterials();
4103 if(!fTransformationMatrices) CreateTransformationMatrices();
4104 if(!fBasicObjects) CreateBasicObjects();
4105 SetLadder(); // Generating the ladder of Layer5 and Layer6
4106 const Int_t kssdlayladdernumber[fgklayernumber] =
4107 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4108 /////////////////////////////////////////////////////////////
4109 // Generating mother volumes for Layer5 and Layer6
4110 /////////////////////////////////////////////////////////////
e5bf64ae 4111 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4112 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
bf210566 4113 Int_t *ladderindex[fgklayernumber];
4114 Int_t index[fgklayernumber] = {8,9};
4115 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4116 for(Int_t i=0; i<fgklayernumber; i++)
4117 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4118 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4119 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4120 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4121 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4122 }
44285dfa 4123 /////////////////////////////////////////////////////////////
bf210566 4124 // Deallocating memory
4125 /////////////////////////////////////////////////////////////
7b208ef4 4126 for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
d7599219 4127}
4128////////////////////////////////////////////////////////////////////////////////
4129void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4130 /////////////////////////////////////////////////////////////
4131 // Insert the layer 5 in the mother volume.
4132 /////////////////////////////////////////////////////////////
4133 if (! moth) {
160835d5 4134 AliError("Can't insert layer5, mother is null!\n");
44285dfa 4135 return;
4136 };
bf210566 4137 if(!fSSDLayer5) SetLayer();
4138 fMotherVol = moth;
4139 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4140 + fgkLay5CenterITSPosition);
4141 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4142 }
d7599219 4143////////////////////////////////////////////////////////////////////////////////
4144void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4145 /////////////////////////////////////////////////////////////
4146 // Insert the layer 6 in the mother volume.
4147 /////////////////////////////////////////////////////////////
4148 if (! moth) {
160835d5 4149 AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
44285dfa 4150 return;
4151 };
bf210566 4152 if(!fSSDLayer6) SetLayer();
4153 fMotherVol = moth;
4154 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4155 + fgkLay6CenterITSPosition);
4156 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4157 }
bf210566 4158 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4159 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4160 /////////////////////////////////////////////////////////////
4161 // Method generating the Arc structure of Ladder Support
4162 /////////////////////////////////////////////////////////////
4163 const Int_t kssdlayladdernumber[fgklayernumber] =
4164 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4165 Double_t mountingsupportedge[fgklayernumber];
4166 Double_t mountingblockratio[fgklayernumber];
4167 Double_t theta[fgklayernumber];
4168 Double_t phi[fgklayernumber];
4169 Double_t psi0[fgklayernumber];
4170 Double_t deltapsi[fgklayernumber];
4171 TVector3* mountingsupportedgevector[fgklayernumber];
4172 for(Int_t i=0; i<fgklayernumber; i++){
4173 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4174 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4175 * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4176 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4177 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4178 / kssdlayladdernumber[i])));
4179 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4180 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4181 mountingsupportedgevector[i] = new TVector3();
60e55aee 4182 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4183 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4184 (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4185 (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
9b0c60ab 4186 psi0[i] = 0.5*TMath::Pi()-phi[i];
4187 deltapsi[i] = (theta[i]+phi[i])/nedges;
4188 }
4189 TVector3** vertex[fgklayernumber];
4190 TList* vertexlist[fgklayernumber];
4191 Int_t indexedge[fgklayernumber] = {0,0};
4192 for(Int_t i=0; i<fgklayernumber; i++){
4193 vertex[i] = new TVector3*[nedges+1];
4194 vertexlist[i] = new TList();
4195 }
4196 for(Int_t i=0; i<fgklayernumber; i++){
4197 for(Int_t j=0; j<nedges+1; j++){
4198 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
c2aad3ae 4199 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]), 0);
9b0c60ab 4200 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4201 vertexlist[i]->Add(vertex[i][j]);
4202 }
4203 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4204 }
4205 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4206 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4207 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4208 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4209 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4210 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4211 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4212 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4213 for(Int_t i=0; i<fgklayernumber; i++){
4214 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4215 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4216 xcentervertex[i] = new Double_t[indexedge[i]+3];
4217 ycentervertex[i] = new Double_t[indexedge[i]+3];
4218 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4219 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4220 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4221 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4222 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4223 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4224 ((TVector3*)vertexlist[i]->At(j))->X();
4225 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4226 ((TVector3*)vertexlist[i]->At(j))->Y();
4227 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4228 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4229 if(j<indexedge[i]+1){
4230 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4231 ((TVector3*)vertexlist[i]->At(j))->X();
4232 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4233 ((TVector3*)vertexlist[i]->At(j))->Y();
4234 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4235 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4236 }
4237 }
4238 xsidevertex[i][1] = xsidevertex[i][0];
4239 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4240 xsidevertex[i][2] = xsidevertex[i][3];
4241 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4242 xcentervertex[i][1] = xcentervertex[i][0];
4243 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4244 xcentervertex[i][2] = xcentervertex[i][3];
4245 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4246 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4247 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4248 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4249 ycenterlowervertex[i][0] = ysidevertex[i][0];
4250 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4251 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4252 }
4253 /////////////////////////////////////////////////////////////
4254 // Building the Arc Structure of Ladder Supports
4255 /////////////////////////////////////////////////////////////
4256 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4257 TGeoXtru* centermountingsupportshape[fgklayernumber];
4258 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4259 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4260 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4261 TGeoVolume* centermountingblocksupport[fgklayernumber];
4262 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4263 TGeoVolume* centerladdersupportpiece[fgklayernumber];
a3f8715e 4264 char sidemountingblockname[100];
4265 char centermountingblockname[100];
4266 char sideladdersupportpiecename[100];
4267 char centerladdersupportpiecename[100];
9b0c60ab 4268 for(Int_t i=0; i<fgklayernumber; i++){
045be90c 4269 snprintf(sidemountingblockname,100,"MountingBlockSupportSideLay%dArc",i+5);
4270 snprintf(centermountingblockname,100,"MountingBlockSupportCenterLay%dArc",i+5);
4271 snprintf(sideladdersupportpiecename,100,"SideLadderSupportPieceLay%d",i+5);
4272 snprintf(centerladdersupportpiecename,100,"CenterLadderSupportPieceLay%d",i+5);
4273 sidemountingblocksupportshape[i] = new TGeoXtru(2);
9b0c60ab 4274 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4275 xsidevertex[i],ysidevertex[i]);
4276 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4277 -fgkMountingBlockSupportWidth[0]);
4278 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4279 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4280 sidemountingblocksupportshape[i],
4281 fSSDAlCoolBlockMedium);
4282 sidemountingblocksupport[i]->SetLineColor(9);
4283 centermountingsupportshape[i] = new TGeoXtru(2);
4284 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4285 xcentervertex[i],ycentervertex[i]);
4286 centermountingsupportshape[i]->DefineSection(0,0.);
4287 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4288 -fgkMountingBlockSupportWidth[0]);
160835d5 4289
9b0c60ab 4290 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4291 centermountingsupportshape[i],
4292 fSSDAlCoolBlockMedium);
4293 centermountingblocksupport[i]->SetLineColor(9);
4294 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4295 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4296 xsidelowervertex[i],ysidelowervertex[i]);
4297 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4298 -fgkMountingBlockSupportWidth[0]);
4299 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4300 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4301 sideladdersupportpieceshape[i],
e21cdd03 4302 fSSDCarbonFiberMedium);
9b0c60ab 4303 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4304 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4305 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4306 xcenterlowervertex[i],ycenterlowervertex[i]);
4307 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4308 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4309 -fgkMountingBlockSupportWidth[0]);
4310 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4311 centerladdersupportpieceshape[i],
e21cdd03 4312 fSSDCarbonFiberMedium);
9b0c60ab 4313 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4314 }
4315 /////////////////////////////////////////////////////////////
4316 // Building the Up Structure of Ladder Supports
4317 /////////////////////////////////////////////////////////////
4318 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4319 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4320 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4321 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4322 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4323 //////////////////////////////////////////////////////////
4324 // Setting the volume for TGeoXtru Mounting Block Piece
4325 //////////////////////////////////////////////////////////
4326 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4327 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4328 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4329 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4330 TGeoVolume* mountingblockpieceup[fgklayernumber];
4331 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4332 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4333 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4334 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
a3f8715e 4335 char mountingblockpiecedownname[100];
4336 char mountingblockpieceupname[100];
9b0c60ab 4337 for(Int_t i=0; i<fgklayernumber; i++){
4338 ///////////////////////////
4339 // Mounting Block Down Vertex
4340 ///////////////////////////
4341 mountingblockpiecedownshape[i] = new TGeoXtru(2);
045be90c 4342 snprintf(mountingblockpiecedownname,100,"MountingBlockPieceDownLay%d",i+5);
9b0c60ab 4343 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4344 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4345 + fgkMountingBlockSupportDownHeight
4346 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4347 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4348 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4349 + fgkSSDMountingBlockHeight[1]
4350 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4351 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4352 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4353 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4354 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4355 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4356 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4357 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4358 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4359 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4360 + fgkSSDMountingBlockHeight[2]
4361 - fgkSSDMountingBlockHeight[0];
4362 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4363 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4364 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4365 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4366 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4367 mountingblockpiecedownyvertex[i]);
4368 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4369 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4370 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
e21cdd03 4371 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
9b0c60ab 4372 mountingblockpiecedown[i]->SetLineColor(fColorG10);
160835d5 4373
9b0c60ab 4374 ///////////////////////////
4375 // Mounting Block Up Vertex
4376 ///////////////////////////
4377 mountingblockpieceupshape[i] = new TGeoXtru(2);
045be90c 4378 snprintf(mountingblockpieceupname,100,"MountingBlockPieceUpLay%d",i+5);
9b0c60ab 4379 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4380 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4381 + fgkMountingBlockSupportUpHeight[i]
4382 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4383 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4384 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4385 + fgkSSDMountingBlockHeight[1]
4386 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4387 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4388 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4389 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4390 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4391 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4392 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4393 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4394 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4395 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4396 + fgkSSDMountingBlockHeight[2]
4397 - fgkSSDMountingBlockHeight[0];
4398 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4399 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4400 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4401 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
160835d5 4402
9b0c60ab 4403 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4404 mountingblockpieceupyvertex[i]);
4405 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4406 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4407 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
e21cdd03 4408 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
9b0c60ab 4409 mountingblockpieceup[i]->SetLineColor(fColorG10);
4410 }
4411 ///////////////////////////////////////////////////////////////////
4412 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4413 ///////////////////////////////////////////////////////////////////
4414 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4415 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4416 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4417 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4418 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4419 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4420 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4421 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
a3f8715e 4422 char mountingblocksupportrapezoidowname[100];
4423 char mountingblocksupportrapezoidupname[100];
9b0c60ab 4424 Double_t scalefactor = 3./4.;
4425 for(Int_t i=0; i<fgklayernumber; i++){
4426 ////////////////////////////////////////////
4427 // Mounting Block Support Down Trapezoid Vertex
4428 ////////////////////////////////////////////
4429 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4430 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4431 - mountingsupportedge[i];
4432 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4433 mountingblocksupportrapezoidownxvertex[i][1] =
4434 mountingblocksupportrapezoidownxvertex[i][0];
4435 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4436 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4437 - mountingblockpiecedownyvertex[i][0]);
4438 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4439 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4440 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4441 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4442 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4443 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
160835d5 4444
9b0c60ab 4445 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4446 mountingblocksupportrapezoidownyvertex[i]);
4447 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4448 -fgkMountingBlockSupportWidth[0]);
4449 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
045be90c 4450 snprintf(mountingblocksupportrapezoidowname,100,"MountingBlockSuppTrapezoidDownLay%d",i+5);
9b0c60ab 4451 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
e21cdd03 4452 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4453 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4454 ////////////////////////////////////////////
4455 // Mounting Block Support Up Trapezoid Vertex
4456 ////////////////////////////////////////////
4457 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4458 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4459 - mountingsupportedge[i];
4460 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4461 mountingblocksupportrapezoidupxvertex[i][1] =
4462 mountingblocksupportrapezoidupxvertex[i][0];
4463 mountingblocksupportrapezoidupyvertex[i][1] =
4464 mountingblockpieceupyvertex[i][0]
4465 + scalefactor*(mountingblockpieceupyvertex[i][1]
4466 - mountingblockpieceupyvertex[i][0]);
4467 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4468 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4469 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4470 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4471 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4472 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
160835d5 4473
9b0c60ab 4474 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4475 mountingblocksupportrapezoidupyvertex[i]);
4476 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4477 -fgkMountingBlockSupportWidth[0]);
4478 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
045be90c 4479 snprintf(mountingblocksupportrapezoidupname,100,"MountingBlockSuppTrapezoidUpLay%d",i+5);
9b0c60ab 4480 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
e21cdd03 4481 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4482 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4483 }
4484 ///////////////////////////////////////////////////////////////////
4485 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4486 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4487 Double_t boxoriginup[fgklayernumber][2][3];
4488 Double_t boxorigindown[fgklayernumber][2][3];
a3f8715e 4489 char mountingblocksupportboxdownname[100];
4490 char mountingblocksupportboxupname[100];
9b0c60ab 4491 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4492 mountingblocksupportrot->SetAngles(90.,180.,-90);
4493 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4494 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4495 TGeoHMatrix* laddersupportmatrix[2];
4496 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4497 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4498 /////////////////////////////////////////////////////////////
4499 // Creating Mother Volume for Containment
4500 /////////////////////////////////////////////////////////////
4501 Double_t *xmothervertex[fgklayernumber];
4502 Double_t *ymothervertex[fgklayernumber];
4503 for(Int_t i=0; i<fgklayernumber; i++){
4504 xmothervertex[i] = new Double_t[8];
4505 ymothervertex[i] = new Double_t[8];
4506 }
4507 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4508 TGeoVolume* downmotherladdersupport[fgklayernumber];
4509 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
160835d5 4510 TGeoVolume* upmotherladdersupport[fgklayernumber];
a3f8715e 4511 char upmotheladdersupportname[100];
4512 char downmotheladdersupportname[100];
9b0c60ab 4513 for(Int_t i=0; i<fgklayernumber; i++){
4514 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4515 - mountingsupportedge[i];
4516 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4517 xmothervertex[i][1] = xmothervertex[i][0];
4518 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4519 + fgkMountingBlockSupportWidth[0];
4520 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4521 ymothervertex[i][2] = ymothervertex[i][1];
4522 xmothervertex[i][3] = xmothervertex[i][2];
4523 ymothervertex[i][3] = -ymothervertex[i][0];
4524 xmothervertex[i][4] = -xmothervertex[i][0];
4525 ymothervertex[i][4] = ymothervertex[i][3];
4526 xmothervertex[i][5] = xmothervertex[i][4];
4527 ymothervertex[i][5] = -ymothervertex[i][1];
4528 xmothervertex[i][6] = -xmothervertex[i][2];
4529 ymothervertex[i][6] = ymothervertex[i][5];
4530 xmothervertex[i][7] = xmothervertex[i][6];
4531 ymothervertex[i][7] = ymothervertex[i][0];
160835d5 4532
045be90c 4533 snprintf(downmotheladdersupportname,100,"LadderSupportDownLay%d",i+5);
4534 snprintf(upmotheladdersupportname,100,"LadderSupportUpLay%d",i+5);
160835d5 4535
4536 downmotherladdersupportshape[i] = new TGeoXtru(2);
9b0c60ab 4537 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4538 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
160835d5 4539 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
9b0c60ab 4540 + fgkMountingBlockSupportDownHeight
4541 + fgkSSDMountingBlockHeight[1]
4542 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4543 - fgkSSDModuleCoolingBlockToSensor
4544 - fgkSSDLadderVerticalDisalignment);
4545
4546// - fgkSSDModuleVerticalDisalignment);
4547 //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4548
4549 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4550 downmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4551 upmotherladdersupportshape[i] = new TGeoXtru(2);
4552 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4553 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4554 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4555 + fgkMountingBlockSupportUpHeight[i]
4556 + fgkSSDMountingBlockHeight[1]
4557 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4558 - fgkSSDModuleCoolingBlockToSensor
4559 - fgkSSDLadderVerticalDisalignment);
4560
4561 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4562 upmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4563 }
4564 for(Int_t i=0; i<fgklayernumber; i++){
4565 /////////////////////////
4566 // Setting the box origin
4567 /////////////////////////
4568 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4569 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4570 + 0.5*fgkMountingBlockSupportDownHeight
4571 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4572 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4573 - 0.5*fgkMountingBlockSupportWidth[0];
4574
4575 boxorigindown[i][1][0] = 0.0;
4576 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4577 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4578 - fgkMountingBlockSupportWidth[0]);
4579
4580 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4581 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4582 + 0.5*fgkMountingBlockSupportUpHeight[i]
4583 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4584 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4585 - 0.5*fgkMountingBlockSupportWidth[0];
4586
4587 boxoriginup[i][1][0] = 0.0;
160835d5 4588 boxoriginup[i][1][1] = boxoriginup[i][0][1];
9b0c60ab 4589 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4590 - fgkMountingBlockSupportWidth[0]);
4591
4592 /////////////////////////
4593 // Setting the boxes
4594 /////////////////////////
4595 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4596 + fgkSSDMountingBlockLength[0]),
160835d5 4597 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4598 0.5*fgkMountingBlockSupportWidth[0],
4599 boxorigindown[i][0]);
160835d5 4600 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4601 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4602 0.5*(fgkMountingBlockSupportWidth[1]
4603 - fgkMountingBlockSupportWidth[0]),
4604 boxorigindown[i][1]);
4605
4606 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4607 + fgkSSDMountingBlockLength[0]),
160835d5 4608 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4609 0.5*fgkMountingBlockSupportWidth[0],
4610 boxoriginup[i][0]);
160835d5 4611
9b0c60ab 4612 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
160835d5 4613 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4614 0.5*(fgkMountingBlockSupportWidth[1]
4615 - fgkMountingBlockSupportWidth[0]),
4616 boxoriginup[i][1]);
4617 ///////////////////////////////////////
160835d5 4618 // Adding the Volumes to Mother Volume
9b0c60ab 4619 ///////////////////////////////////////
4620 for(Int_t j=0; j<2; j++){
045be90c 4621 snprintf(mountingblocksupportboxdownname,100,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4622 snprintf(mountingblocksupportboxupname,100,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4623 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4624 mountingblocksupportboxdownshape[i][j],
4625 fSSDCarbonFiberMedium);
4626 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4627 mountingblocksupportboxupshape[i][j],
4628 fSSDCarbonFiberMedium);
9b0c60ab 4629 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4630 mountingblocksupportboxup[i][j]->SetLineColor(9);
4631 for(Int_t k=0; k<2; k++){
4632 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
160835d5 4633 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
9b0c60ab 4634 }
4635 }
4636 for(Int_t k=0; k<2; k++){
4637 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4638 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4639 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4640 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
160835d5 4641 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4642 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4643 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
160835d5 4644 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4645 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4646 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4647 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4648 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4649 }
4650 }
4651 TList* laddersupportlist = new TList();
4652 laddersupportlist->Add(downmotherladdersupport[0]);
4653 laddersupportlist->Add(upmotherladdersupport[0]);
4654 laddersupportlist->Add(downmotherladdersupport[1]);
4655 laddersupportlist->Add(upmotherladdersupport[1]);
4656 /////////////////////////////////////////////////////////////
4657 // Deallocating memory
4658 /////////////////////////////////////////////////////////////
4659 for(Int_t i=0; i<fgklayernumber; i++){
4660 for(Int_t j=0; j<nedges+1; j++)
4661 delete vertex[i][j];
4662 delete mountingsupportedgevector[i];
4663 delete [] vertex[i];
4664 delete vertexlist[i];
4665 delete [] xsidevertex[i];
4666 delete [] ysidevertex[i];
4667 delete [] xcentervertex[i];
4668 delete [] ycentervertex[i];
4669 delete [] xsidelowervertex[i];
4670 delete [] ysidelowervertex[i];
4671 delete [] xcenterlowervertex[i];
4672 delete [] ycenterlowervertex[i];
7b208ef4 4673 delete [] xmothervertex[i];
4674 delete [] ymothervertex[i];
9b0c60ab 4675 }
3e008bd7 4676 delete [] xsidevertex;
4677 delete [] ysidevertex;
4678 delete [] xcentervertex;
4679 delete [] ycentervertex;
4680 delete [] xsidelowervertex;
4681 delete [] ysidelowervertex;
4682 delete [] xcenterlowervertex;
4683 delete [] ycenterlowervertex;
9b0c60ab 4684 delete globalrefladdersupportrot;
4685 delete mountingblocksupportrot;
4686 /////////////////////
4687 return laddersupportlist;
4688}
4689 ////////////////////////////////////////////////////////////////////////////////
4690void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4691//////////////////////////////////////////
4692// Method Generating Ladder Support Ring
4693//////////////////////////////////////////
4694 if(!fCreateMaterials) CreateMaterials();
4695 if(!fTransformationMatrices) CreateTransformationMatrices();
4696 if(!fBasicObjects) CreateBasicObjects();
4697 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4698 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4699 const Int_t kssdlayladdernumber[fgklayernumber] =
4700 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4701 Double_t mountingsupportedge[fgklayernumber];
4702 Double_t mountingblockratio[fgklayernumber];
4703 Double_t theta[fgklayernumber];
4704 Double_t phi[fgklayernumber];
4705 for(Int_t i=0; i<fgklayernumber; i++){
4706 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4707 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4708 *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4709 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4710 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4711 / kssdlayladdernumber[i])));
4712 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4713 / fgkMountingBlockSupportRadius[i]);
4714 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4715 }
4716 TGeoRotation* globalrot = new TGeoRotation();
4717 globalrot->SetAngles(0.,-90.,0.);
4718 TGeoRotation** laddersupportrot[fgklayernumber];
4719 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4720 for(Int_t i=0; i<fgklayernumber; i++){
4721 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4722 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4723 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4724 laddersupportrot[i][j] = new TGeoRotation();
4725 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4726 switch(i){
4727 case 0: //Ladder of Layer5
4728 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4729 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4730 laddersupportmatrix[i][j]);
4731 break;
4732 case 1: //Ladder of Layer6
4733 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4734 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4735 laddersupportmatrix[i][j]);
4736 break;
4737 }
4738 }
4739 }
4740 /////////////////////////////////////////////////////////////
4741 // Creating Lower Ladder Support
4742 /////////////////////////////////////////////////////////////
4743 TVector3** ringsupportvertex[fgklayernumber];
4744 Double_t angle = 360./nedges;
4745 for(Int_t i=0; i<fgklayernumber; i++){
4746 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4747 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
c2aad3ae 4748 * TMath::Cos(theta[i]), 0);
9b0c60ab 4749 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4750 - mountingsupportedge[i],
c2aad3ae 4751 ringsupportvertex[i][0]->Y(), 0);
9b0c60ab 4752 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
c2aad3ae 4753 ringsupportvertex[i][1]->Y(),0);
9b0c60ab 4754 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4755 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4756 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4757 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4758 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4759 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4760 }
4761 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4762 for(Int_t j=0; j<nedges+1; j++){
4763 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
cd2243fb 4764 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
c2aad3ae 4765 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle), 0);
9b0c60ab 4766 }
4767 }
4768 Double_t **xmothervertex = new Double_t*[fgklayernumber];
4769 Double_t **ymothervertex = new Double_t*[fgklayernumber];
4770 for(Int_t i=0; i<fgklayernumber; i++){
4771 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4772 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4773 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4774 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4775 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4776 }
4777 }
0e8760e5 4778////////////////////////////////////////////////////////////////////////////////
4779// Start Corrections 13/06/08
4780////////////////////////////////////////////////////////////////////////////////
a3f8715e 4781 char lowerladderpconsupportname[100];
0e8760e5 4782 TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4783 TGeoVolume* lowerladderpconsupport[fgklayernumber];
4784 Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4785 Double_t lowerladderpconradiusmax[fgklayernumber];
4786 Double_t lowerladderpconradiusmin[fgklayernumber];
4787 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4788 lowerladdersupportrot->SetAngles(90.,180.,-90);
4789 for(Int_t i=0; i<fgklayernumber; i++){
4790 lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4791 * TMath::Cos(theta[i]);
cd2243fb 4792 lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
0e8760e5 4793 }
4794 for(Int_t i=0; i<fgklayernumber; i++){
4795/////////////////////////// Modified Version ?///////////////////
4796 lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4797 for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
4798 lowerladderpconezsection[j],lowerladderpconradiusmin[i],
4799 lowerladderpconradiusmax[i]);
045be90c 4800 snprintf(lowerladderpconsupportname,100,"LowerLadderPConSupportNameLay%d",i+5);
0e8760e5 4801 lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
4802 lowerladderpconsupport[i]->SetLineColor(fColorAl);
4803 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
4804 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
4805 }
4806////////////////////////////////////////////////////////////////////////////////
4807// End Corrections 13/06/08
4808////////////////////////////////////////////////////////////////////////////////
4809 /*char lowerladdersupportname[30];
9b0c60ab 4810 TGeoXtru* lowerladdersupportshape[fgklayernumber];
4811 TGeoVolume* lowerladdersupport[fgklayernumber];
4812 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4813 lowerladdersupportrot->SetAngles(90.,180.,-90);
4814 for(Int_t i=0; i<fgklayernumber; i++){
4815 lowerladdersupportshape[i] = new TGeoXtru(2);
4816 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
4817 xmothervertex[i],ymothervertex[i]);
4818 lowerladdersupportshape[i]->DefineSection(0,0.);
4819 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4820 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
4821 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
4822 lowerladdersupportshape[i],fSSDSupportRingAl);
4823 lowerladdersupport[i]->SetLineColor(fColorAl);
4824 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
4825 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
0e8760e5 4826 }*/
9b0c60ab 4827 /////////////////////////////////////////////////////////////
4828 // Deallocating memory
4829 /////////////////////////////////////////////////////////////
4830 for(Int_t i=0; i<fgklayernumber; i++){
4831 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
4832 delete ringsupportvertex[i][j];
4833 delete [] ringsupportvertex[i];
4834 }
4835 for(Int_t i=0; i<fgklayernumber; i++){
4836 delete [] xmothervertex[i];
4837 delete [] ymothervertex[i];
4838 }
7b208ef4 4839 delete [] xmothervertex;
4840 delete [] ymothervertex;
9b0c60ab 4841 delete globalrot;
4842 for(Int_t i=0; i<fgklayernumber; i++){
4843 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
4844 delete laddersupportrot[i][j];
4845 delete [] laddersupportrot[i];
4846 }
4847 }
4848 ////////////////////////////////////////////////////////////////////////////////
4849 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
4850 /////////////////////////////////////////////////////////////
4851 // Method generating Endcap CoverPlate
4852 /////////////////////////////////////////////////////////////
4853 // Holes Definition
4854 ///////////////////
4855 Int_t nendcapcoverplateholedges = 30;
4856 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
4857 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
4858 0.5*fgkEndCapCoverPlateThickness};
851c0ce3 4859 TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
9b0c60ab 4860 nendcapcoverplateholedges,holesection);
4861 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 4862 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4863 endcapcoverplatesmallhole->SetLineColor(6);
851c0ce3 4864 TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
9b0c60ab 4865 nendcapcoverplateholedges,holesection);
4866 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 4867 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4868 endcapcoverplatebighole->SetLineColor(6);
4869 //////////////////////////
4870 // Screw Piece Definition
4871 //////////////////////////
4872 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
4873 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
4874 CosD(0.5*smallscrewangle),
4875 0.5*fgkEndCapCoverPlateThickness);
4876 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
4877 endcapsmallscrewpieceshape,
4878 fSSDCoolingTubePhynox);
4879 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
4880 ///////////////////
4881 // Box Definition
4882 ///////////////////
4883 TGeoBBox* endcapcoverplateboxshape[4];
4884 TGeoVolume* endcapcoverplatebox[4];
4885 Double_t boxorigin[5][3];
4886 boxorigin[0][0] = 0.;
4887 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
4888 boxorigin[0][2] = 0.;
4889
4890 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
4891 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
4892 boxorigin[1][2] = 0.;
4893
4894 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
4895 + fgkEndCapCoverPlateSmallHoleSeparation[1];
4896 boxorigin[2][1] = boxorigin[1][1];
4897 boxorigin[2][2] = 0.;
4898
4899 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
4900 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
4901 boxorigin[3][1] = boxorigin[1][1];
4902 boxorigin[3][2] = 0.;
4903
4904 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4905 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
4906 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
4907 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
4908
4909 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4910 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4911 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4912 + fgkEndCapCoverPlateSmallHoleRadius,
4913 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
4914
4915 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4916 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4917 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4918 + fgkEndCapCoverPlateSmallHoleRadius,
4919 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
4920
4921 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
4922 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4923 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4924 + fgkEndCapCoverPlateSmallHoleRadius,
4925 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
4926
4927 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 4928 fSSDAlCoolBlockMedium);
9b0c60ab 4929 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 4930 fSSDAlCoolBlockMedium);
9b0c60ab 4931 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 4932 fSSDAlCoolBlockMedium);
9b0c60ab 4933 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 4934 fSSDAlCoolBlockMedium);
9b0c60ab 4935 endcapcoverplatebox[0]->SetLineColor(6);
4936 endcapcoverplatebox[1]->SetLineColor(6);
4937 endcapcoverplatebox[2]->SetLineColor(6);
4938 endcapcoverplatebox[3]->SetLineColor(6);
4939 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
4940 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4941 fgkEndCapCoverPlateSmallHoleRadius,
4942 0.5*fgkEndCapCoverPlateThickness,
4943 endcapfillingboxorigin);
4944 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 4945 fSSDAlCoolBlockMedium);
9b0c60ab 4946 endcapfillingbox->SetLineColor(6);
4947 ////////////////////////////
851c0ce3 4948 // Contour shape Definition
9b0c60ab 4949 ////////////////////////////
4950 const Int_t kcontourvertexnumber = 10;
4951 Double_t xcontourvertex[kcontourvertexnumber];
4952 Double_t ycontourvertex[kcontourvertexnumber];
4953 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
4954 xcontourvertex[1] = xcontourvertex[0];
4955 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4956 xcontourvertex[3] = xcontourvertex[2];
4957 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
4958 xcontourvertex[5] = xcontourvertex[4];
4959 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4960 xcontourvertex[7] = xcontourvertex[6];
4961 xcontourvertex[8] = xcontourvertex[4];
4962 xcontourvertex[9] = xcontourvertex[8];
4963 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4964 - (kendcapcoverplatesmallholenumber[1]-1)
4965 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4966 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
4967 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4968 ycontourvertex[2] = ycontourvertex[1];
4969 ycontourvertex[3] = ycontourvertex[0];
4970 ycontourvertex[4] = ycontourvertex[3];
4971 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
4972 ycontourvertex[6] = ycontourvertex[5];
4973 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
4974 * fgkEndCapCoverPlateSmallHoleSeparation[2]
4975 + fgkEndCapCoverPlateSmallHoleRadius;
4976 ycontourvertex[8] = ycontourvertex[7];
4977 ycontourvertex[9] = ycontourvertex[0];
851c0ce3 4978
4979 Double_t xboxin, dxboxin, yboxin, dyboxin;
4980 Double_t xboxout, dxboxout, yboxout, dyboxout;
4981 Double_t coordmin, coordmax;
4982 coordmin = -fgkEndCapCoverPlateLength[0];
4983 coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4984 xboxout = 0.5*(coordmin+coordmax);
4985 dxboxout = 0.5*(coordmax-coordmin);
4986 coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4987 - (kendcapcoverplatesmallholenumber[1]-1)
4988 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4989 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
4990 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4991 yboxout = 0.5*(coordmin+coordmax);
4992 dyboxout = 0.5*(coordmax-coordmin);
4993 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
4994 coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4995 xboxin = 0.5*(coordmin+coordmax);
4996 dxboxin = 0.5*(coordmax-coordmin);
4997 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
4998 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
4999 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5000 + fgkEndCapCoverPlateSmallHoleRadius;
5001 yboxin = 0.5*(coordmin+coordmax);
5002 dyboxin = 0.5*(coordmax-coordmin);
5003 new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5004 TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5005 xboxout, yboxout, 0.);
5006 trendCapCoverPlateContourboxout->RegisterYourself();
5007 new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5008 TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5009 xboxin, yboxin, 0.);
5010 trendCapCoverPlateContourboxin->RegisterYourself();
5011 TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5012 "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5013
e21cdd03 5014 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5015 fSSDAlCoolBlockMedium);
9b0c60ab 5016 contour->SetLineColor(6);
5017 /////////////////////////////
851c0ce3 5018 // Hole Contour Shape Definition
9b0c60ab 5019 ////////////////////////////
851c0ce3 5020 coordmin = xcontourvertex[0];
5021 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5022 xboxout = 0.5*(coordmin+coordmax);
5023 dxboxout = 0.5*(coordmax-coordmin);
5024 coordmin = ycontourvertex[1];
5025 coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5026 yboxout = 0.5*(coordmin+coordmax);
5027 dyboxout = 0.5*(coordmax-coordmin);
5028 coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5029 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5030 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5031 xboxin = 0.5*(coordmin+coordmax);
5032 dxboxin = 0.5*(coordmax-coordmin);
5033 coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5034 - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5035 coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5036 yboxin = 0.5*(coordmin+coordmax);
5037 dyboxin = 0.5*(coordmax-coordmin);
5038 new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5039 TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5040 xboxout, yboxout, 0.);
5041 trendCapCoverPlateContourboxout1->RegisterYourself();
5042 new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5043 TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5044 xboxin, yboxin, 0.);
5045 trendCapCoverPlateContourboxin1->RegisterYourself();
5046 TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5047 "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5048
5049
5050 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5051 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5052 xboxout = 0.5*(coordmin+coordmax);
5053 dxboxout = 0.5*(coordmax-coordmin);
5054 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5055 - fgkEndCapCoverPlateWidth[0]);
5056 coordmax = ycontourvertex[0];
5057 yboxout = 0.5*(coordmin+coordmax);
5058 dyboxout = 0.5*(coordmax-coordmin);
5059 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5060 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5061 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5062 xboxin = 0.5*(coordmin+coordmax);
5063 dxboxin = 0.5*(coordmax-coordmin);
5064 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5065 - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5066 - fgkEndCapCoverPlateWidth[0]
5067 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5068 coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5069 yboxin = 0.5*(coordmin+coordmax);
5070 dyboxin = 0.5*(coordmax-coordmin);
5071 new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5072 TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5073 xboxout, yboxout, 0.);
5074 trendCapCoverPlateContourboxout2->RegisterYourself();
5075 new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5076 TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5077 xboxin, yboxin, 0.);
5078 trendCapCoverPlateContourboxin2->RegisterYourself();
5079 TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5080 "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5081
5082// const Int_t kholecontourvertexnumber = 10;
5083
9b0c60ab 5084 Double_t xholecontourvertex[2][kcontourvertexnumber];
5085 Double_t yholecontourvertex[2][kcontourvertexnumber];
5086 xholecontourvertex[0][0] = xcontourvertex[0];
5087 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5088 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5089 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5090 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5091 + 0.5*(fgkEndCapCoverPlateLength[2]
5092 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5093 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5094 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5095 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5096 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5097 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5098 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5099
5100 yholecontourvertex[0][0] = ycontourvertex[1];
5101 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5102 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5103 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5104 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5105 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5106 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5107 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5108 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5109 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5110 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5111
5112 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5113 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5114 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5115 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5116 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5117 + 0.5*(fgkEndCapCoverPlateLength[2]
5118 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5119 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5120 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5121 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5122 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5123 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5124 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5125
5126 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5127 - fgkEndCapCoverPlateWidth[0]);
5128 yholecontourvertex[1][1] = ycontourvertex[0];
5129 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5130 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5131 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5132 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5133 - fgkEndCapCoverPlateWidth[0]
5134 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5135 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5136 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5137 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5138 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5139
9b0c60ab 5140 TGeoVolume* holecontour[2];
851c0ce3 5141 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
e21cdd03 5142 fSSDAlCoolBlockMedium);
9b0c60ab 5143 holecontour[0]->SetLineColor(6);
851c0ce3 5144 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
e21cdd03 5145 fSSDAlCoolBlockMedium);
9b0c60ab 5146 holecontour[1]->SetLineColor(6);
5147 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5148 + fgkEndCapCoverPlateLength[2],0.,0.);
5149 TGeoTranslation* bigholetrans[3];
5150 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5151 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5152 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5153 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5154 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5155 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5156 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5157 /////////////////////////////////
5158 // Mother Volume Xtru Definition
5159 /////////////////////////////////
5160 const Int_t kmothervertexnumber = 12;
5161 Double_t xmothervertex[kmothervertexnumber];
5162 Double_t ymothervertex[kmothervertexnumber];
5163 xmothervertex[0] = xcontourvertex[0];
5164 xmothervertex[1] = xmothervertex[0];
5165 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5166 xmothervertex[3] = xmothervertex[2];
5167 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5168 xmothervertex[5] = xmothervertex[4];
5169 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5170 xmothervertex[7] = xmothervertex[6];
5171 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5172 + fgkEndCapCoverPlateLength[2];
5173 xmothervertex[9] = xmothervertex[8];
5174 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5175 xmothervertex[11] = xmothervertex[10];
5176
5177 ymothervertex[0] = ycontourvertex[0];
5178 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5179 ymothervertex[2] = ymothervertex[1];
5180 ymothervertex[3] = ycontourvertex[1];
5181 ymothervertex[4] = ymothervertex[3];
5182 ymothervertex[5] = ymothervertex[1];
5183 ymothervertex[6] = ymothervertex[5];
5184 ymothervertex[7] = ymothervertex[0];
5185 ymothervertex[8] = ymothervertex[7];
5186 ymothervertex[9] = ymothervertex[8]
5187 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5188 ymothervertex[10] = ymothervertex[9];
5189 ymothervertex[11] = ymothervertex[8];
5190 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5191 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5192 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5193 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5194 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5195 ////////////////////////////////////////
5196 // Adding Nodes
5197 ////////////////////////////////////////
5198// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5199 TGeoTranslation*** endcapcoverplatesmallholetrans;
5200 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5201 Double_t transx[4] = {0,
5202 fgkEndCapCoverPlateSmallHoleSeparation[0],
5203 fgkEndCapCoverPlateSmallHoleSeparation[0]
5204 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5205 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5206 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5207 Int_t index = 0;
5208 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5209 endcapcoverplatesmallholetrans[i] =
5210 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5211 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5212 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5213 endcapcoverplatesmallholetrans[i][j] =
5214 new TGeoTranslation(transx[i],
5215 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5216 if(index!=10){
5217 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5218 index,endcapcoverplatesmallholetrans[i][j]);
5219 mothercoverplate->AddNode(endcapsmallscrewpiece,
5220 index,endcapcoverplatesmallholetrans[i][j]);
5221 }
5222 if(j<kendcapcoverplatesmallholenumber[1]-1)
5223 mothercoverplate->AddNode(endcapcoverplatebox[0],
5224 index,endcapcoverplatesmallholetrans[i][j]);
5225 }
5226 }
5227 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5228 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5229 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5230 mothercoverplate->AddNode(endcapfillingbox,1);
5231 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5232 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5233 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5234 mothercoverplate->AddNode(holecontour[0],1);
5235 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5236 mothercoverplate->AddNode(holecontour[1],1);
5237 mothercoverplate->AddNode(contour,1);
045be90c 5238
5239 for (Int_t i = 0; i < kendcapcoverplatesmallholenumber[0]; i++)
5240 delete [] endcapcoverplatesmallholetrans[i];
5241 delete [] endcapcoverplatesmallholetrans;
9b0c60ab 5242 /////////////////////////////////
5243 return mothercoverplate;
5244 }
5245 ////////////////////////////////////////////////////////////////////////////////
5246 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5247 /////////////////////////////////////////////////////////////
5248 // Getting EndCap Cooling Tube
5249 /////////////////////////////////////////////////////////////
5250 TGeoTorus* endcapcoolingtubetorushape[5];
5251 TGeoVolume* endcapcoolingtubetorus[5];
5252 TGeoTube* endcapcoolingtubeshape[4];
5253 TGeoVolume* endcapcoolingtube[4];
a3f8715e 5254 char endcapcoolingtubetorusname[100];
5255 char endcapcoolingtubename[100];
9b0c60ab 5256 TGeoTorus* endcapcoolingwatertubetorushape[5];
5257 TGeoVolume* endcapcoolingwatertubetorus[5];
5258 TGeoTube* endcapcoolingwatertubeshape[4];
5259 TGeoVolume* endcapcoolingwatertube[4];
a3f8715e 5260 char endcapcoolingwatertubetorusname[100];
5261 char endcapcoolingwatertubename[100];
9b0c60ab 5262 for(Int_t i=0; i<5; i++){
045be90c 5263 snprintf(endcapcoolingtubetorusname,100,"EndCapCoolingTubeTorus%d",i+1);
5264 snprintf(endcapcoolingtubename,100,"EndCapCoolingTube%d",i+1);
5265 snprintf(endcapcoolingwatertubetorusname,100,"EndCapCoolingWaterTubeTorus%d",i+1);
5266 snprintf(endcapcoolingwatertubename,100,"EndCapCoolingWaterTube%d",i+1);
5267 if(i==3){
5268 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5269 fgkEndCapCoolingTubeRadiusMin,
5270 fgkEndCapCoolingTubeRadiusMax,
5271 90.0,fgkEndCapCoolingTubeAngle[3]);
5272 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5273 0.,fgkEndCapCoolingTubeRadiusMin,
5274 90.0,fgkEndCapCoolingTubeAngle[3]);
5275 }
5276 else{
5277 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5278 :fgkEndCapCoolingTubeAxialRadius[1],
5279 fgkEndCapCoolingTubeRadiusMin,
5280 fgkEndCapCoolingTubeRadiusMax,
5281 0.,fgkEndCapCoolingTubeAngle[i]);
5282 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5283 :fgkEndCapCoolingTubeAxialRadius[1],
5284 0.,fgkEndCapCoolingTubeRadiusMin,
5285 0.,fgkEndCapCoolingTubeAngle[i]);
9b0c60ab 5286 }
9b0c60ab 5287 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5288 endcapcoolingtubetorushape[i],
5289 fSSDCoolingTubePhynox);
5290 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5291 endcapcoolingwatertubetorushape[i],
5292 fSSDCoolingTubeWater);
5293 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5294 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5295 if(i<4){
5296 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5297 fgkEndCapCoolingTubeRadiusMax,
5298 0.5*fgkEndCapCoolingTubeLength[i]);
5299 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5300 0.5*fgkEndCapCoolingTubeLength[i]);
5301 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5302 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5303 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5304 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5305 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5306 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5307 }
5308 }
5309 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5310 /////////////////////////////////////////
5311 // Transformation for Volume Positioning
5312 /////////////////////////////////////////
5313 TGeoCombiTrans* coolingtubecombitrans[6];
5314 TGeoRotation* coolingtuberot[8];
5315 TGeoTranslation* coolingtubetrans[6];
5316 TGeoHMatrix* coolingtubematrix[4];
5317 TGeoCombiTrans* torustubecombitrans[4];
5318 TGeoRotation* torustuberot[7];
5319 TGeoTranslation* torustubetrans[4];
5320 TGeoHMatrix* torustubematrix[5];
5321 TGeoCombiTrans* coolingwatertubecombitrans[6];
5322 TGeoRotation* coolingwatertuberot[8];
5323 TGeoTranslation* coolingwatertubetrans[6];
5324 TGeoHMatrix* coolingwatertubematrix[4];
5325 TGeoCombiTrans* toruswatertubecombitrans[4];
5326 TGeoRotation* toruswatertuberot[7];
5327 TGeoTranslation* toruswatertubetrans[4];
5328 TGeoHMatrix* toruswatertubematrix[5];
5329 for(Int_t i=0; i<8; i++){
5330 if(i<6){
5331 coolingtubetrans[i] = new TGeoTranslation();
5332 coolingwatertubetrans[i] = new TGeoTranslation();
5333 }
5334 if(i<8){
5335 coolingtuberot[i] = new TGeoRotation();
5336 coolingwatertuberot[i] = new TGeoRotation();
5337 }
5338 if(i<4){
5339 torustubetrans[i] = new TGeoTranslation();
5340 toruswatertubetrans[i] = new TGeoTranslation();
5341 }
5342 if(i<7){
5343 torustuberot[i] = new TGeoRotation();
5344 toruswatertuberot[i] = new TGeoRotation();
5345 }
5346 }
5347 /////////////////////////////////////////
5348 // Transformation for Inox Volume Positioning
5349 /////////////////////////////////////////
5350 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5351 -endcapcoolingtubeshape[0]->GetDz(),0.);
5352 coolingtuberot[0]->SetAngles(0.,90.,0.);
5353 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5354 *coolingtuberot[0]);
5355
5356 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5357 coolingtuberot[1]->SetAngles(0.,90.,0.);
5358 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5359 *coolingtuberot[1]);
5360
5361 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5362 *CosD(fgkEndCapCoolingTubeAngle[0]),
5363 fgkEndCapCoolingTubeAxialRadius[0]
5364 *SinD(fgkEndCapCoolingTubeAngle[0]),
5365 0.);
5366 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5367 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5368 *coolingtuberot[2]);
5369
5370 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5371 * (*coolingtubecombitrans[1]));
5372
5373 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5374 endcapcoolingtubeshape[1]->GetDz());
5375 torustuberot[0]->SetAngles(0.,90.,0.);
5376 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5377
5378 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5379
5380 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5381 -endcapcoolingtubeshape[2]->GetDz(),0.);
5382 coolingtuberot[3]->SetAngles(0.,90.,0.);
5383 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5384 *coolingtuberot[3]);
5385 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5386 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5387 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5388
5389 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5390 endcapcoolingtubeshape[2]->GetDz());
5391 torustuberot[1]->SetAngles(0.,90.,0.);
5392 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5393 torustuberot[2]->SetAngles(180.,0.,0.);
5394 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5395 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5396
5397 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5398 -fgkEndCapCoolingTubeAxialRadius[0]);
5399 torustuberot[3]->SetAngles(0.,90.,0.);
5400 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5401 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5402 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5403 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5404
5405 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5406 fgkEndCapCoolingTubeAxialRadius[0],0.);
5407 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5408 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5409 *coolingtuberot[5]);
5410 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5411 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5412 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5413
5414 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5415 endcapcoolingtubeshape[0]->GetDz());
5416 torustuberot[5]->SetAngles(0.,90.,0.);
5417 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5418 torustuberot[6]->SetAngles(-90.,0.,0.);
5419 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5420 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5421
5422 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5423 endcapcoolingtubeshape[3]->GetDz(),0.);
5424 coolingtuberot[6]->SetAngles(0.,90.,0.);
5425 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5426 *coolingtuberot[6]);
5427 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5428 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5429 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5430 /////////////////////////////////////////
5431 // Transformation for Water Volume Positioning
5432 /////////////////////////////////////////
5433 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5434 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5435 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5436 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5437 *coolingwatertuberot[0]);
5438
5439 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5440 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5441 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5442 *coolingwatertuberot[1]);
5443
5444 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5445 *CosD(fgkEndCapCoolingTubeAngle[0]),
5446 fgkEndCapCoolingTubeAxialRadius[0]
5447 *SinD(fgkEndCapCoolingTubeAngle[0]),
5448 0.);
5449 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5450 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5451 *coolingwatertuberot[2]);
5452
5453 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5454 * (*coolingwatertubecombitrans[1]));
5455
5456 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5457 endcapcoolingwatertubeshape[1]->GetDz());
5458 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5459 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5460 *toruswatertuberot[0]);
5461
5462 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5463 * (*toruswatertubecombitrans[0]));
5464
5465 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5466 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5467 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5468 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5469 *coolingwatertuberot[3]);
5470 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5471 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5472 * (*coolingwatertubecombitrans[3]));
5473 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5474
5475 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5476 endcapcoolingwatertubeshape[2]->GetDz());
5477 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5478 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5479 *toruswatertuberot[1]);
5480 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5481 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5482 * (*toruswatertubecombitrans[1]));
5483 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5484
5485 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5486 -fgkEndCapCoolingTubeAxialRadius[0]);
5487 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5488 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5489 *toruswatertuberot[3]);
5490 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5491 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5492 * (*toruswatertubecombitrans[2]));
5493 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5494
5495 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5496 fgkEndCapCoolingTubeAxialRadius[0],0.);
5497 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5498 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5499 *coolingwatertuberot[5]);
5500 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5501 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5502 * (*coolingwatertubecombitrans[4]));
5503 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5504
5505 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5506 endcapcoolingwatertubeshape[0]->GetDz());
5507 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5508 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5509 *toruswatertuberot[5]);
5510 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5511 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5512 * (*toruswatertubecombitrans[3]));
5513 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5514
5515 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5516 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5517 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5518 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5519 *coolingwatertuberot[6]);
5520 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5521 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5522 * (*coolingwatertubecombitrans[5]));
5523 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5524 /////////////////////////////////////////
5525 // Positioning Volumes
5526 /////////////////////////////////////////
5527 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5528 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5529
5530 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5531 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5532
5533 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5534 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5535
5536 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5537 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5538
5539 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5540 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5541
5542 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5543 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5544
5545 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5546 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5547
5548 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5549 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5550
5551 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5552 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5553
5554 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5555 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5556 /////////////////////////////////////////////////////////////
5557 // Deallocating memory
5558 /////////////////////////////////////////////////////////////
5559 for(Int_t i=0; i<8; i++){
5560 if(i<6){
5561 delete coolingtubetrans[i];
5562 delete coolingwatertubetrans[i];
5563 if(i!=0){
5564 delete coolingtubecombitrans[i];
5565 delete coolingwatertubecombitrans[i];
5566 }
5567 }
5568 if(i<8){
5569 delete coolingtuberot[i];
5570 delete coolingwatertuberot[i];
5571 }
5572 if(i<4){
5573 delete torustubetrans[i];
5574 delete toruswatertubetrans[i];
5575 delete torustubecombitrans[i];
5576 delete toruswatertubecombitrans[i];
5577 }
5578 if(i<7){
5579 delete torustuberot[i];
5580 delete toruswatertuberot[i];
5581 }
5582 }
5583 /////////////////////////////////////////////////////////////
5584 return endcapcoolingtubemother;
5585 }
5586 ////////////////////////////////////////////////////////////////////////////////
5587 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5588 /////////////////////////////////////////////////////////////
5589 // Getting EndCap Cover Side
5590 /////////////////////////////////////////////////////////////
5591 const Int_t kendcapcoverholenumber[2] = {7,5};
5592 const Int_t kvertexnumber = 15;
5593 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5594 xvertex[0] = 0.0;
5595 xvertex[1] = xvertex[0];
5596 xvertex[2] = fgkEndCapSideCoverLength[0];
5597 xvertex[3] = fgkEndCapSideCoverLength[1];
5598 xvertex[4] = xvertex[3];
5599 xvertex[5] = fgkEndCapSideCoverLength[2];
5600 xvertex[6] = xvertex[5];
5601 xvertex[7] = xvertex[2];
5602 xvertex[8] = xvertex[7];
5603 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5604 xvertex[10] = xvertex[9];
5605 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5606 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5607 * fgkEndCapSideCoverLength[4];
5608 xvertex[12] = xvertex[11];
5609 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5610 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5611 * fgkEndCapSideCoverLength[4];
5612 xvertex[14] = xvertex[13];
5613 yvertex[0] = 0.0;
5614 yvertex[1] = fgkEndCapSideCoverWidth[0];
5615 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5616 yvertex[3] = yvertex[2];
5617 yvertex[4] = fgkEndCapSideCoverWidth[1];
5618 yvertex[5] = yvertex[4];
5619 yvertex[6] = yvertex[0];
5620 yvertex[7] = yvertex[6];
5621 yvertex[8] = fgkEndCapSideCoverWidth[6];
5622 yvertex[9] = yvertex[8];
5623 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5624 yvertex[11] = yvertex[10];
5625 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5626 yvertex[13] = yvertex[12];
5627 yvertex[14] = yvertex[6];
851c0ce3 5628 TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5629 endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5630 endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5631 endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5632 endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5633 TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5634 endcapsidecovershapein->SetName("endcapsidecovershapein");
5635 endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5636 endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5637 endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5638
5639
5640 TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
9b0c60ab 5641 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5642 endcapsidecovershape,fSSDCoolingTubePhynox);
5643 endcapsidecover->SetLineColor(fColorPhynox);
5644 ////////////////////////////////////////////
5645 // Defininition of Mother Volume
5646 ////////////////////////////////////////////
5647 const Int_t kmothervertexnumber = 7;
5648 Double_t xmothervertex[kmothervertexnumber];
5649 Double_t ymothervertex[kmothervertexnumber];
5650 for(Int_t i=0; i<kmothervertexnumber; i++){
5651 xmothervertex[i] = xvertex[i];
5652 ymothervertex[i] = yvertex[i];
5653 }
5654 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5655 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5656 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5657 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5658 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5659 endcapsidecovermothershape,fSSDAir);
5660 ////////////////////////////////////////////
5661 endcapsidecovermother->AddNode(endcapsidecover,1);
5662 TGeoBBox* endcapsidecoverboxshape[4];
5663 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5664 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5665 0.5*fgkEndCapSideCoverLength[4],
5666 0.5*fgkEndCapSideCoverThickness);
5667 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5668 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5669 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5670 - fgkEndCapSideCoverLength[4]),
5671 0.5*fgkEndCapSideCoverThickness);
5672 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5673 0.5*fgkEndCapSideCoverLength[4],
5674 0.5*fgkEndCapSideCoverThickness);
5675 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5676 0.5*fgkEndCapSideCoverWidth[5],
5677 0.5*fgkEndCapSideCoverThickness);
5678 TGeoVolume* endcapsidecoverbox[4];
5679 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5680 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5681 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5682 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5683 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5684// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5685 TGeoTranslation** endcapsidecoverboxtrans;
5686 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5687 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5688 + fgkEndCapSideCoverLength[0],
5689 endcapsidecoverboxshape[0]->GetDY()
5690 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5691 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5692 + xvertex[11],
5693 endcapsidecoverboxshape[1]->GetDY()
5694 + yvertex[12],0.);
5695 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5696 + xvertex[11],
5697 endcapsidecoverboxshape[2]->GetDY()
5698 + yvertex[12]
5699 + 2.*endcapsidecoverboxshape[1]->GetDY()
5700 + fgkEndCapSideCoverWidth[5],0.);
5701 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5702 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5703 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5704 for(Int_t i=0; i<2; i++)
5705 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5706 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5707 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5708 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5709 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5710 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5711 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5712 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5713 }
5714 for(Int_t i=0; i<2; i++)
5715 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5716 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5717 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5718 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5719 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5720 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5721 +fgkEndCapSideCoverLength[4]),0.0);
5722 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5723 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5724 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5725 +i*(kendcapcoverholenumber[1]-1)+j]);
5726 }
b7bd9ab6 5727 delete [] endcapsidecoverboxtrans;
5728 return endcapsidecovermother;
9b0c60ab 5729 }
5730 ////////////////////////////////////////////////////////////////////////////////
5731 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5732 ////////////////////////////////////////////////////////////////////////////////
5733 // Method returning Interface Card A, Interface Card B, Supply Card
5734 ////////////////////////////////////////////////////////////////////////////////
5735 /////////////////////
5736 // Supply Card
5737 /////////////////////
5738 // Electronic Board Back Al Plane
5739 const Int_t kelectboardbackvertexnumber = 8;
5740 Double_t xelectboardback[kelectboardbackvertexnumber];
5741 Double_t yelectboardback[kelectboardbackvertexnumber];
5742 xelectboardback[0] = 0.0;
5743 xelectboardback[1] = xelectboardback[0];
5744 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5745 xelectboardback[3] = xelectboardback[2];
5746 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5747 xelectboardback[5] = xelectboardback[4];
5748 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5749 xelectboardback[7] = xelectboardback[6];
5750
5751 yelectboardback[0] = 0.0;
5752 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5753 yelectboardback[2] = yelectboardback[1];
5754 yelectboardback[3] = yelectboardback[0];
5755 yelectboardback[4] = yelectboardback[3];
5756 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5757 yelectboardback[6] = yelectboardback[5];
5758 yelectboardback[7] = yelectboardback[4];
5759 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5760 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5761 xelectboardback,yelectboardback);
5762 electboardbackshape->DefineSection(0,0.0);
5763 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5764 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5765 electboardbackshape,fSSDSupportRingAl);
5766 electboardback->SetLineColor(fColorAl);
5767 // Electronic Board Kapton Layer
5768 const Int_t kelectlayervertexnumber = 8;
5769 Double_t xelectlayer[kelectlayervertexnumber];
5770 Double_t yelectlayer[kelectlayervertexnumber];
5771 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5772 xelectlayer[1] = xelectlayer[0];
5773 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5774 xelectlayer[3] = xelectlayer[2];
5775 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5776
5777 yelectlayer[0] = 0.0;
5778 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5779 yelectlayer[2] = yelectlayer[1];
5780 yelectlayer[3] = yelectlayer[0];
5781 yelectlayer[4] = yelectlayer[3];
5782 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5783 yelectlayer[6] = yelectlayer[5];
5784 yelectlayer[7] = yelectlayer[4];
5785 TGeoXtru* electlayershape = new TGeoXtru(2);
5786 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5787 electlayershape->DefineSection(0,0.0);
5788 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5789 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5790 electlayershape,fSSDKaptonFlexMedium);
5791 electlayer->SetLineColor(fColorKapton);
5792 // JMD Connector Female
5793 const Int_t kjmdconnectorvertexnumber = 6;
5794 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5795 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5796 xjmdconnectorvertex[0] = 0.0;
5797 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5798 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5799 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5800 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5801 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5802
5803 yjmdconnectorvertex[0] = 0.0;
5804 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5805 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5806 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5807 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5808 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5809 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5810 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5811 yjmdconnectorvertex);
5812 jmdconnectorshape->DefineSection(0,0.0);
5813 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5814 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5815 jmdconnectorshape,fSSDMountingBlockMedium);
5816 jmdconnector->SetLineColor(fColorG10);
5817 // Top Cable Connector
5818 const Int_t kcableconnectorvertexnumber = 8;
5819 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5820 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5821 xconnectorvertex[0] = 0.0;
5822 xconnectorvertex[1] = xconnectorvertex[0];
5823 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5824 xconnectorvertex[3] = xconnectorvertex[2];
5825 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5826 - fgkEndCapCardCableConnectorLength[2];
5827 xconnectorvertex[5] = xconnectorvertex[4];
5828 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5829 xconnectorvertex[7] = xconnectorvertex[6];
5830
5831 yconnectorvertex[0] = 0.0;
5832 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5833 yconnectorvertex[2] = yconnectorvertex[1];
5834 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5835 yconnectorvertex[4] = yconnectorvertex[3];
5836 yconnectorvertex[5] = yconnectorvertex[1];
5837 yconnectorvertex[6] = yconnectorvertex[5];
5838 yconnectorvertex[7] = yconnectorvertex[0];
5839 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5840 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5841 yconnectorvertex);
5842 cableconnectorshape->DefineSection(0,0.0);
5843 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5844 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5845 cableconnectorshape,fSSDMountingBlockMedium);
5846 cableconnector->SetLineColor(fColorG10);
5847 // Strip Connection
5848 TGeoBBox* endcapstripconnectionshape =
5849 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5850 0.5*fgkEndCapStripConnectionThickness,
5851 0.5*fgkEndCapStripConnectionWidth);
5852 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5853 endcapstripconnectionshape,
5854 fSSDSupportRingAl);
5855 endcapstripconnection->SetLineColor(fColorAl);
5856 // Interface Card B
5857 const Int_t kcardBvertexnumber = 12;
5858 Double_t xcardBvertexnumber[kcardBvertexnumber];
5859 Double_t ycardBvertexnumber[kcardBvertexnumber];
5860
5861 xcardBvertexnumber[0] = 0.0;
5862 xcardBvertexnumber[1] = xcardBvertexnumber[0];
5863 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5864 xcardBvertexnumber[3] = xcardBvertexnumber[2];
5865 xcardBvertexnumber[4] = xcardBvertexnumber[1];
5866 xcardBvertexnumber[5] = xcardBvertexnumber[4];
5867 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5868 xcardBvertexnumber[7] = xcardBvertexnumber[6];
5869 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5870 xcardBvertexnumber[9] = xcardBvertexnumber[8];
5871 xcardBvertexnumber[10] = xcardBvertexnumber[7];
5872 xcardBvertexnumber[11] = xcardBvertexnumber[10];
5873
5874 ycardBvertexnumber[0] = 0.0;
5875 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
5876 ycardBvertexnumber[2] = ycardBvertexnumber[1];
5877 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5878 ycardBvertexnumber[4] = ycardBvertexnumber[3];
5879 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5880 ycardBvertexnumber[6] = ycardBvertexnumber[5];
5881 ycardBvertexnumber[7] = ycardBvertexnumber[4];
5882 ycardBvertexnumber[8] = ycardBvertexnumber[7];
5883 ycardBvertexnumber[9] = ycardBvertexnumber[1];
5884 ycardBvertexnumber[10] = ycardBvertexnumber[9];
5885 ycardBvertexnumber[11] = ycardBvertexnumber[0];
5886
5887 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5888 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5889 interfacecardBshape->DefineSection(0,0.);
5890 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5891 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5892 fSSDMountingBlockMedium);
5893 interfacecardB->SetLineColor(46);
5894 // Interface Card B Electronic Board
5895 const Int_t kelectboardcardBvertexnumber = 14;
5896 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5897 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5898
5899 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5900 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
5901 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
5902 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
5903 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
5904 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
5905 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
5906 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
5907 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
5908 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
5909 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
5910 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
5911 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
5912 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
5913
5914 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
5915 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
5916 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
5917 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
5918 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
5919 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
5920 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
5921 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
5922 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
5923 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
5924 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
5925 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
5926 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
5927 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
5928
5929 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
5930 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
5931 xelectboardcardBvertex,yelectboardcardBvertex);
5932 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
5933 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
5934 + fgkEndCapInterfaceElectBoardCardBThickness);
5935 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
5936 fSSDSupportRingAl);
5937 electboardcardB->SetLineColor(fColorAl);
5938 // Generating Stiffener 2
5939 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
5940 0.5*fgkEndCapStiffenerThickness,
5941 0.5*fgkEndCapStiffenerLength);
5942 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
5943 endcapstiffener->SetLineColor(fColorAl);
5944 // Generating Mother Interface Card B Container
5945 const Int_t kinterfacecardBmothervertexnumber = 10;
5946 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5947 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5948
5949 xinterfacecardBmothervertex[0] = 0.0;
5950 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
5951 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
5952 + fgkEndCapInterfaceCardBThickness;
5953 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
5954 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
5955 + fgkEndCapInterfaceElectBoardCardBThickness;
5956 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
5957 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
5958 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
5959 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
5960 + fgkEndCapCardJMDConnectorLength[0];
5961 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
5962
5963 yinterfacecardBmothervertex[0] = 0.0;
5964 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
5965 + fgkEndCapInterfaceCardBWidth[1]
5966 + fgkEndCapInterfaceCardBWidth[2];
5967 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
5968 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
5969 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
5970 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
5971 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
5972 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
5973 + fgkEndCapCardJMDConnectorWidth[0]
5974 + fgkEndCapCardJMDConnectorWidth[1];
5975 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
5976 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
5977 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
5978 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
5979 xinterfacecardBmothervertex,
5980 yinterfacecardBmothervertex);
5981 interfacecardBmothershape->DefineSection(0,-1.e-15);
5982 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
5983 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
5984 interfacecardBmothershape,fSSDAir);
5985 electboardcardB->SetLineColor(fColorAl);
5986 // Positioning Volumes Mother Interface Card B Container
5987 TGeoRotation* interfacecardBrot = new TGeoRotation();
5988 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
5989 interfacecardBrot->SetAngles(90.,-90.,-90.);
5990 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
5991 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
5992 TGeoRotation* electboardcardBrot = new TGeoRotation();
5993 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
5994 electboardcardBrot->SetAngles(90.,90.,-90.);
5995 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
5996 TGeoCombiTrans* electboardcardBcombitrans =
5997 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
5998 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
5999 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6000 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6001 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6002 TGeoTranslation* jmdconnectorcardBtrans[3];
6003 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6004 for(Int_t i=0; i<3; i++){
6005 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6006 + fgkEndCapCardJMDConnectorLength[0],
6007 fgkEndCapCardElectBoardLayerWidth[1],
6008 0.5*fgkEndCapCardJMDConnectorThickness
6009 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6010 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6011 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6012 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6013 *jmdconnectorcardBrot);
6014 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6015 }
6016 // Mother Supply Card Container
6017 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6018 // Interface Card Container
6019 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6020 // Placing Volumes in Mother Supply Card Container
6021 // JMD Connector Positioning
6022 TGeoTranslation* jmdconnectortrans[2];
6023 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6024 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6025 fgkEndCapCardElectBoardBackLength[0]
6026 - fgkEndCapCardJMDConnectorThickness
6027 - fgkEndCapCardJMDConnectorToLayer);
6028 TGeoRotation* jmdconnectorot = new TGeoRotation();
6029 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6030 + 2.*fgkEndCapCardJMDConnectorLength[0]
6031 + 2.*fgkEndCapCardElectBoardLayerThickness,
6032 fgkEndCapCardElectBoardLayerWidth[1],
6033 fgkEndCapCardJMDConnectorThickness
6034 + fgkEndCapCardJMDConnectorToLayer);
6035 jmdconnectorot->SetAngles(90.,180.,-90);
6036 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6037 * jmdconnectorot);
6038 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6039 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6040 // Top Cable Connector Placing
6041 TGeoRotation* cableconnectorot[2];
6042 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6043 TGeoTranslation* cableconnectortrans[3];
6044 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6045 cableconnectorot[0]->SetAngles(90.,0.,0.);
6046 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6047 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6048 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6049 *cableconnectorot[0]);
6050 TGeoHMatrix* cableconnectormatrix[2];
6051 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6052 new TGeoHMatrix((*cableconnectorot[1])
6053 *(*cableconnectorcombitrans));
6054 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6055 - fgkEndCapCardCableConnectorThickness,
6056 fgkEndCapCardCableConnectorLength[0]
6057 + fgkEndCapCardCableConnectorToLayer);
6058 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6059 - 2.*fgkEndCapCardCableConnectorThickness
6060 - fgkEndCapCardCableConnectorDistance,
6061 fgkEndCapCardCableConnectorLength[0]
6062 + fgkEndCapCardCableConnectorToLayer);
6063 for(Int_t i=0; i<2; i++){
6064 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6065 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6066 }
6067 TGeoRotation* electboardbackrot = new TGeoRotation();
6068 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6069 electboardbackrot->SetAngles(90.,-90.,-90.);
6070 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6071 + fgkEndCapCardJMDConnectorLength[0]
6072 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6073 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6074 *electboardbackrot);
6075 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6076 // Electronic Board Kapton Layer Positioning
6077 TGeoRotation* electlayerrot = new TGeoRotation();
6078 TGeoTranslation* electlayertrans[2];
6079 TGeoCombiTrans* electlayercombitrans[2];
6080 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6081 electlayerrot->SetAngles(90.,-90.,-90.);
6082 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6083 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6084 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6085 + 2.*fgkEndCapCardElectBoardLayerThickness
6086 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6087 for(Int_t i=0; i<2; i++){
6088 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6089 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6090 }
6091 // Placing Volumes in Mother Interface Card Container
6092 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6093 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6094 for(Int_t i=0; i<2; i++){
6095 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6096 }
6097 /////////////////////////////////////////////////////////////
6098 // Generation of Card Interface Container
6099 /////////////////////////////////////////////////////////////
6100 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6101 - fgkEndCapCardJMDConnectorLength[0]
6102 - fgkEndCapInterfaceCardBThickness
6103 - 9.*fgkEndCapStripConnectionThickness
6104 - 8.*fgkEndCapCardElectBoardBackThickness;
6105 const Int_t kcardinterfacecontainervertexnumber = 14;
6106 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6107 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6108 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6109 - 7.0*fgkEndCapStripConnectionThickness;
6110 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6111 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6112 + fgkEndCapStripConnectionThickness
6113 - fgkEndCapCardElectBoardLayerThickness
6114 - fgkEndCapCardCableConnectorWidth[0];
6115 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6116 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6117 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6118 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6119 + 2.0*fgkEndCapStripConnectionThickness;
6120 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6121 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6122 + fgkEndCapInterfaceCardBThickness;
6123 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6124 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6125 + fgkEndCapInterfaceElectBoardCardBThickness;
6126 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6127 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6128 - fgkEndCapInterfaceElectBoardCardBThickness
6129 + fgkEndCapCardJMDConnectorLength[0]
6130 + stiffenertransx+fgkEndCapStiffenerWidth;
6131 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6132
6133 ycardinterfacecontainervertex[0] = 0.;
6134 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6135 + fgkEndCapCardJMDConnectorWidth[0]
6136 + fgkEndCapCardJMDConnectorWidth[1];
6137 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6138 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6139 - fgkEndCapStripConnectionWidth;
6140 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6141 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6142 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6143 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6144 + fgkEndCapInterfaceCardBWidth[1]
6145 + fgkEndCapInterfaceCardBWidth[2];
6146 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6147 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6148 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6149 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6150 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6151 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6152
6153 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6154 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6155 xcardinterfacecontainervertex,
6156 ycardinterfacecontainervertex);
6157 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6158 - fgkEndCapCardElectBoardBackLength[0]));
6159 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6160 + fgkEndCapCardElectBoardBackLength[0]));
6161 TGeoVolume** cardinterfacecontainer;
6162 cardinterfacecontainer = new TGeoVolume*[4];
6163 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6164 interfacecardmothershape,fSSDAir);
6165 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6166 interfacecardmothershape,fSSDAir);
6167 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6168 interfacecardmothershape,fSSDAir);
6169 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6170 interfacecardmothershape,fSSDAir);
6171 /////////////////////////////////
6172 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6173 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6174 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6175 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6176 /////////////////////////////////
6177 TGeoRotation* endcapstripconnectionrot[2];
6178 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6179 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6180 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6181 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6182 * (*endcapstripconnectionrot[0]));
6183 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6184 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6185 -0.5*fgkEndCapCardElectBoardBackThickness,
6186 fgkEndCapCardElectBoardBackWidth[0]
6187 -endcapstripconnectionshape->GetDZ(),
6188 0.5*fgkEndCapCardElectBoardBackLength[0]);
6189 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6190 TGeoTranslation* cardinterfacetrans[9];
6191 TGeoHMatrix* cardinterfacematrix[9];
6192 for(Int_t i=0; i<7; i++){
6193 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6194 + fgkEndCapCardElectBoardBackThickness),
6195 0.0,0.0);
6196 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6197 * (*endcapstripconnectionmatrix));
6198 }
6199 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6200 + fgkEndCapCardElectBoardBackThickness),
6201 0.0,0.0);
6202 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6203 * (*endcapstripconnectionmatrix));
6204 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6205 + fgkEndCapCardElectBoardBackThickness),
6206 0.0,0.0);
6207 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6208 * (*endcapstripconnectionmatrix));
6209
6210 for(Int_t i=0; i<4; i++){
6211 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6212 cardinterfacematrix[7]);
6213 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6214 cardinterfacematrix[8]);
6215 }
6216 TGeoTranslation* mothersupplycardtrans =
6217 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6218 + 2.*fgkEndCapCardJMDConnectorLength[0]
6219 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6220 TGeoHMatrix* mothersupplycardmatrix[7];
6221 Int_t index[4] = {1,1,1,1};
6222 for(Int_t i=0; i<7; i++){
6223 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6224 * (*mothersupplycardtrans));
6225 for(Int_t j=0; j<4; j++){
6226 switch(j){
6227 case 0: //Layer5 EndCap Left Side
6228 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6229 cardinterfacematrix[i]);
6230 if(i!=0){
6231 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6232 mothersupplycardmatrix[i]);
6233 index[j]++;
6234
6235 }
6236 break;
6237 case 1: //Layer5 EndCap Rigth Side
6238 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6239 cardinterfacematrix[i]);
6240 if(i>0&&i<6){
6241 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6242 mothersupplycardmatrix[i]);
6243 index[j]++;
6244 }
6245 break;
6246 case 2: //Layer6 EndCap Left Side
6247 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6248 cardinterfacematrix[i]);
6249 if(i!=6){
6250 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6251 mothersupplycardmatrix[i]);
6252 index[j]++;
6253 }
6254 break;
6255 case 3: //Layer6 EndCap Right Side
6256 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6257 cardinterfacematrix[i]);
6258 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6259 mothersupplycardmatrix[i]);
6260 index[j]++;
6261 break;
6262 }
6263 }
6264 }
6265 // Positioning Interface
6266 TGeoTranslation* motherinterfacecardtrans =
6267 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6268 +0.5*fgkEndCapCardElectBoardBackThickness
6269 -fgkEndCapCardElectBoardLayerThickness
6270 +fgkEndCapStripConnectionThickness,0.,0.);
6271 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6272 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6273 // Positioning Interface Card B
6274 TGeoTranslation* interfacecardBmothertrans =
6275 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6276 + 2.*fgkEndCapStripConnectionThickness
6277 + fgkEndCapCardElectBoardBackThickness,0.,
6278 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6279 - fgkEndCapCardElectBoardBackLength[0]));
6280 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6281 interfacecardBmothertrans);
6282 // Positioning Stiffener
6283 TGeoTranslation* endcapstiffenertrans =
6284 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6285 + 2.0*fgkEndCapStripConnectionThickness
6286 + fgkEndCapInterfaceCardBThickness
6287 + fgkEndCapCardJMDConnectorLength[0]
6288 + stiffenertransx
6289 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6290 endcapstiffenershape->GetDZ()
6291 - 0.5*(fgkEndCapStiffenerLength
6292 - fgkEndCapCardElectBoardBackLength[0]));
6293 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6294 /////////////////////////////////////////////////////////////
6295 // Deallocating memory
6296 /////////////////////////////////////////////////////////////
6297 delete interfacecardBrot;
6298 delete interfacecardBtrans;
6299 delete electboardcardBtrans;
6300 delete electboardcardBrot;
6301 delete jmdconnectorcardBrot;
6302 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6303 delete jmdconnectorot;
6304 delete jmdconnectortrans[1];
6305 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6306 delete cableconnectorcombitrans;
6307 delete electboardbacktrans;
6308 delete electboardbackrot;
6309 delete electlayerrot;
6310 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6311 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6312 delete mothersupplycardtrans;
6313 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6314 /////////////////////////////////////////////////////////////
6315 return cardinterfacecontainer;
6316 }
6317 ////////////////////////////////////////////////////////////////////////////////
6318 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6319 /////////////////////////////////////////////////////////////
6320 // Method returning EndCap Mother Volume
6321 /////////////////////////////////////////////////////////////
6322 const Int_t kendcapcoverplatesmallholenumber = 9;
6323 Double_t endcapmotherorigin[3];
6324 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6325 + 0.5 *(fgkEndCapCoverPlateLength[3]
6326 + 2.0 * fgkEndCapCoverPlateLength[2]);
6327 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6328 - fgkEndCapCoverPlateWidth[2]
6329 - (kendcapcoverplatesmallholenumber-1)
6330 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6331 + 0.5*(fgkEndCapSideCoverLength[2]
6332 + fgkEndCapCoverPlateWidth[1]
6333 - fgkEndCapCoverPlateWidth[0])
6334 - (fgkEndCapCoverPlateWidth[1]
6335 - fgkEndCapCoverPlateWidth[0]);
6336 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6337 + 2.*fgkEndCapCoolingTubeRadiusMax
6338 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6339 + fgkEndCapSideCoverWidth[1]
6340 + fgkEndCapSideCoverThickness
6341 + fgkEndCapKaptonFoilThickness);
6342 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6343 + 2.0* fgkEndCapCoverPlateLength[2]
6344 + 2.0* fgkEndCapSideCoverThickness),
6345 0.5* (fgkEndCapSideCoverLength[2]
6346 + fgkEndCapCoverPlateWidth[1]
6347 - fgkEndCapCoverPlateWidth[0]),
6348 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6349 + fgkEndCapSideCoverWidth[1]
6350 + fgkEndCapSideCoverThickness
6351 + fgkEndCapKaptonFoilThickness),
6352 endcapmotherorigin);
6353 TGeoVolume** endcapassembly;
6354 endcapassembly = new TGeoVolume*[4];
6355 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6356 endcapmothershape,fSSDAir);
6357 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6358 endcapmothershape,fSSDAir);
6359 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6360 endcapmothershape,fSSDAir);
6361 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6362 endcapmothershape,fSSDAir);
6363 /////////////////////////////////
6364 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6365 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6366 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6367 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6368 /////////////////////////////////
6369 /////////////////////////////////////////////////////
6370 // Placing Endcap Cover Plate
6371 /////////////////////////////////////////////////////
6372 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6373 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6374 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6375 TGeoCombiTrans* endcapcoverplatecombitrans =
6376 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6377 endcapcoverplaterot);
6378 TGeoTranslation* endcapcoverplatetrans =
6379 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6380 TGeoHMatrix* endcapcoverplatematrix =
6381 new TGeoHMatrix((*endcapcoverplatetrans)
6382 * (*endcapcoverplatecombitrans));
6383 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6384 /////////////////////////////////////////////////////
6385 // Placing Endcap Side Cover
6386 /////////////////////////////////////////////////////
6387 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6388 TGeoRotation* endcapsidecoverot[2];
6389 TGeoCombiTrans* endcapsidecovercombitrans[3];
6390 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6391 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6392 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6393 - 0.5*(fgkEndCapCoverPlateWidth[0]
6394 - fgkEndCapCoverPlateWidth[2]
6395 - (kendcapcoverplatesmallholenumber-1)
6396 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6397 + 0.*fgkEndCapCoverPlateWidth[0]
6398 + fgkEndCapSideCoverLength[2],
6399 0.5*(fgkEndCapSideCoverThickness
6400 + fgkEndCapCoverPlateThickness)
6401 - 0.5*fgkEndCapCoverPlateThickness,
6402 endcapsidecoverot[0]);
6403 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6404 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6405 0.5*fgkEndCapCoverPlateThickness
6406 -fgkEndCapSideCoverWidth[1],
6407 endcapsidecoverot[1]);
6408 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6409 +fgkEndCapCoverPlateLength[3]
6410 +2.*fgkEndCapCoverPlateLength[2]
6411 +fgkEndCapSideCoverThickness,0.0,
6412 0.5*fgkEndCapCoverPlateThickness
6413 -fgkEndCapSideCoverWidth[1],
6414 endcapsidecoverot[1]);
6415 TGeoHMatrix* endcapsidecovermatrix[2];
6416 for(Int_t i=0; i<2; i++){
6417 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6418 * (*endcapsidecovercombitrans[0]));
6419 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6420 endcapsidecovermatrix[i]);
6421 }
6422 /////////////////////////////////////////////////////
6423 // Placing Endcap Cooling Tube
6424 /////////////////////////////////////////////////////
6425 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6426 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6427 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6428 TGeoCombiTrans* endcapccolingtubecombitrans
6429 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6430 + fgkEndCapCoolingTubeAxialRadius[1])
6431 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6432 - fgkEndCapCoolingTubeToCoverSide,
6433 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6434 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6435 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6436 endcapccolingtubecombitrans);
6437 /////////////////////////////////////////////////////
6438 // Placing Screws
6439 /////////////////////////////////////////////////////
6440 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6441 fgkEndCapCoverPlateScrewRadiusMin};
6442 Int_t screwcoverplatedgesnumber[2] = {20,20};
6443 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6444 fgkEndCapCoverPlateThickness
6445 + fgkEndCapCoolingTubeRadiusMax};
851c0ce3 6446 TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
9b0c60ab 6447 screwcoverplatedgesnumber,
6448 screwcoverplatesection);
6449 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6450 screwcoverplateshape,
6451 fSSDCoolingTubePhynox);
6452 screwcoverplate->SetLineColor(12);
6453 Double_t transx[4] = {0,
6454 fgkEndCapCoverPlateSmallHoleSeparation[0],
6455 fgkEndCapCoverPlateSmallHoleSeparation[0]
6456 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6457 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6458 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6459 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6460// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6461 TGeoTranslation*** endcapcoverplatescrewtrans;
6462 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6463 Int_t index = 0;
6464 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6465 endcapcoverplatescrewtrans[i] =
6466 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6467 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6468 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6469 if(index==1||index==9||index==28||index==36){
6470 endcapcoverplatescrewtrans[i][j] =
6471 new TGeoTranslation(transx[i],
6472 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6473 fgkEndCapSideCoverThickness);
6474 }
6475 else{
6476 endcapcoverplatescrewtrans[i][j] =
6477 new TGeoTranslation(transx[i],
6478 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6479 0.);
6480 }
6481 if(index!=19)
6482 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6483 endcapcoverplatescrewtrans[i][j]);
6484 }
6485 }
6486 /////////////////////////////////////////////////////
6487 // Placing Cover Plate Clips
6488 /////////////////////////////////////////////////////
6489 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6490 0.5*fgkEndCapCoverPlateClipWidth,
6491 0.5*fgkEndCapSideCoverThickness);
6492 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6493 endcapcoverplateclipshape,
6494 fSSDCoolingTubePhynox);
6495 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6496 0.5*fgkEndCapCoverPlateDownClipWidth,
6497 0.5*fgkEndCapSideCoverThickness);
6498 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6499 endcapcoverplatedownclipshape,
6500 fSSDCoolingTubePhynox);
6501 TGeoTranslation* endcapcoverplatecliptrans[4];
6502 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6503 - fgkEndCapCoverPlateLength[0]
6504 - fgkEndCapSideCoverThickness,
6505 0.0,
6506 0.5*(fgkEndCapSideCoverThickness
6507 + fgkEndCapCoverPlateThickness));
6508 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6509 - fgkEndCapCoverPlateLength[0]
6510 - fgkEndCapSideCoverThickness,
6511 (kendcapcoverplatescrewnumber[1]-1)
6512 * fgkEndCapSideCoverWidth[5],
6513 0.5*(fgkEndCapSideCoverThickness
6514 + fgkEndCapCoverPlateThickness));
6515 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6516 - fgkEndCapCoverPlateLength[0]
6517 + fgkEndCapCoverPlateLength[1]
6518 + 2.*fgkEndCapCoverPlateLength[0]
6519 - fgkEndCapCoverPlateClipLength
6520 + fgkEndCapSideCoverThickness,
6521 0.0,
6522 0.5*(fgkEndCapSideCoverThickness
6523 + fgkEndCapCoverPlateThickness));
6524 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6525 - fgkEndCapCoverPlateLength[0]
6526 + fgkEndCapCoverPlateLength[1]
6527 + 2.*fgkEndCapCoverPlateLength[0]
6528 - fgkEndCapCoverPlateClipLength
6529 + fgkEndCapSideCoverThickness,
6530 (kendcapcoverplatescrewnumber[1]-1)
6531 * fgkEndCapSideCoverWidth[5],
6532 0.5*(fgkEndCapSideCoverThickness
6533 + fgkEndCapCoverPlateThickness));
6534 endcapcoverplateclip->SetLineColor(fColorPhynox);
6535 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6536 for(Int_t i=0; i<4; i++)
6537 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6538 endcapcoverplatecliptrans[i]);
6539 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6540 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6541 - fgkEndCapCoverPlateLength[0]
6542 - fgkEndCapSideCoverThickness,
6543 0.5*(fgkEndCapCoverPlateDownClipWidth
6544 - fgkEndCapCoverPlateClipWidth),
6545 0.5*(fgkEndCapSideCoverThickness
6546 + fgkEndCapCoverPlateThickness)
6547 - fgkEndCapSideCoverWidth[1]
6548 - fgkEndCapSideCoverThickness);
6549 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6550 - fgkEndCapCoverPlateLength[0]
6551 - fgkEndCapSideCoverThickness,
6552 0.5*(fgkEndCapCoverPlateDownClipWidth
6553 - fgkEndCapCoverPlateClipWidth)
6554 + fgkEndCapSideCoverLength[2]
6555 - fgkEndCapCoverPlateDownClipWidth,
6556 0.5*(fgkEndCapSideCoverThickness
6557 + fgkEndCapCoverPlateThickness)
6558 - fgkEndCapSideCoverWidth[1]
6559 - fgkEndCapSideCoverThickness);
6560 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6561 - fgkEndCapCoverPlateLength[0]
6562 + fgkEndCapSideCoverThickness
6563 + fgkEndCapCoverPlateLength[1]
6564 + 2.0*fgkEndCapCoverPlateLength[0]
6565 - fgkEndCapCoverPlateDownClipLength,
6566 0.5*(fgkEndCapCoverPlateDownClipWidth
6567 - fgkEndCapCoverPlateClipWidth),
6568 0.5*(fgkEndCapSideCoverThickness
6569 + fgkEndCapCoverPlateThickness)
6570 - fgkEndCapSideCoverWidth[1]
6571 - fgkEndCapSideCoverThickness);
6572 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6573 - fgkEndCapCoverPlateLength[0]
6574 + fgkEndCapSideCoverThickness
6575 + fgkEndCapCoverPlateLength[1]
6576 + 2.0*fgkEndCapCoverPlateLength[0]
6577 - fgkEndCapCoverPlateDownClipLength,
6578 0.5*(fgkEndCapCoverPlateDownClipWidth
6579 - fgkEndCapCoverPlateClipWidth)
6580 + fgkEndCapSideCoverLength[2]
6581 - fgkEndCapCoverPlateDownClipWidth,
6582 0.5*(fgkEndCapSideCoverThickness
6583 + fgkEndCapCoverPlateThickness)
6584 - fgkEndCapSideCoverWidth[1]
6585 - fgkEndCapSideCoverThickness);
6586 for(Int_t i=0; i<4; i++)
6587 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6588 endcapcoverplatedowncliptrans[i]);
6589 /////////////////////////////////////////////////////
6590 // Placing Kapton Foil
6591 /////////////////////////////////////////////////////
6592 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6593 0.5*fgkEndCapKaptonFoilWidth,
6594 0.5*fgkEndCapKaptonFoilThickness);
6595 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6596 endcapkaptonfoilshape,
6597 fSSDKaptonFlexMedium);
6598 endcapkaptonfoil->SetLineColor(8);
6599 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6600 0.5*fgkEndCapKaptonFoilWidth
6601 - 0.5*fgkEndCapCoverPlateClipWidth,
6602 0.5*fgkEndCapCoverPlateThickness
6603 - 0.5*fgkEndCapKaptonFoilThickness
6604 - fgkEndCapSideCoverWidth[1]
6605 - fgkEndCapSideCoverThickness);
6606 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6607 /////////////////////////////////////////////////////////////
6608 // Placing Electronic Tubes
6609 /////////////////////////////////////////////////////////////
6610 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6611 - fgkEndCapInterfaceCardBThickness
6612 - 9.*fgkEndCapStripConnectionThickness
6613 - 8.*fgkEndCapCardElectBoardBackThickness,
6614 fgkEndCapKaptonFoilWidth
6615 - fgkEndCapInterfaceCardBThickness
6616 - 9.*fgkEndCapStripConnectionThickness
6617 - 8.*fgkEndCapCardElectBoardBackThickness
6618 - fgkEndCapInterfaceElectBoardCardBThickness};
6619 TGeoVolume* endcapeffectivecables[2];
6620 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6621 fgkEndCapEffectiveCableRadiusMax,
6622 endcapeffectivecableswidth[0],
6623 10,"EndCapEffectiveCables1");
6624 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6625 fgkEndCapEffectiveCableRadiusMax,
6626 endcapeffectivecableswidth[1],
6627 25,"EndCapEffectiveCables2");
6628 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6629 TGeoTranslation* endcapeffectivecablestrans[2];
6630 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6631 - 0.5*endcapeffectivecableswidth[0]
6632 - 0.5*(fgkEndCapCoverPlateWidth[0]
6633 - fgkEndCapCoverPlateWidth[2]
6634 - (kendcapcoverplatesmallholenumber-1)
6635 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6636 + fgkEndCapSideCoverLength[2],
6637 - 0.5*fgkEndCapCoverPlateThickness
6638 - (fgkEndCapCardElectBoardBackWidth[0]
6639 - fgkEndCapInterfaceCardBWidth[0]
6640 - fgkEndCapInterfaceCardBWidth[1]));
6641 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6642 - 0.5*endcapeffectivecableswidth[1]
6643 - 0.5*(fgkEndCapCoverPlateWidth[0]
6644 - fgkEndCapCoverPlateWidth[2]
6645 - (kendcapcoverplatesmallholenumber-1)
6646 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6647 + fgkEndCapSideCoverLength[2],
6648 - 0.5*fgkEndCapCoverPlateThickness
6649 - (fgkEndCapCardElectBoardBackWidth[0]
6650 - fgkEndCapInterfaceCardBWidth[0])
6651 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6652 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6653 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6654 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6655 *endcapeffectivecablesrot);
6656 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6657 *endcapeffectivecablesrot);
47f8de53 6658// for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6659// endcapeffectivecablescombitrans[0]);
9b0c60ab 6660 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6661 endcapeffectivecablescombitrans[1]);
6662 /////////////////////////////////////////////////////////////
6663 // Placing End Cap Cards
6664 /////////////////////////////////////////////////////////////
6665 TGeoVolume** endcapcards = GetEndCapCards();
6666 TGeoRotation* endcapcardsrot[2];
6667 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6668 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6669 TGeoTranslation* endcapcardstrans[2];
6670 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6671 - fgkEndCapCardElectBoardBackLength[0]));
6672 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6673 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6674 TGeoHMatrix* endcapcardsmatrix[2];
6675 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6676 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6677 - fgkEndCapCardJMDConnectorLength[0]
6678 - fgkEndCapInterfaceCardBThickness
6679 - 9.*fgkEndCapStripConnectionThickness
6680 - 8.*fgkEndCapCardElectBoardBackThickness;
6681 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6682 - fgkEndCapCoverPlateLength[0]
6683 + 0.5 * (fgkEndCapCoverPlateLength[3]
6684 + 2.0 * fgkEndCapCoverPlateLength[2]),
6685 - stiffenertransx-fgkEndCapStiffenerWidth
6686 - fgkEndCapCardJMDConnectorLength[0]
6687 - fgkEndCapInterfaceCardBThickness
6688 - 2.0 * fgkEndCapStripConnectionThickness
6689 - 1.5 * fgkEndCapInterfaceCardBThickness
6690 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6691 - fgkEndCapCoverPlateWidth[2]
6692 - (kendcapcoverplatesmallholenumber-1)
6693 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6694 + fgkEndCapKaptonFoilWidth,
6695 0.5*fgkEndCapCoverPlateThickness
6696 - fgkEndCapSideCoverWidth[1]);
6697 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6698 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6699 /////////////////////////////////////////////////////////////
6700 // Deallocating memory
6701 /////////////////////////////////////////////////////////////
6702 delete endcapcoverplaterot;
6703 delete endcapcoverplatecombitrans;
6704 delete endcapcoverplatetrans;
6705 for(Int_t i=0; i<3; i++){
6706 delete endcapsidecovercombitrans[i];
6707 if(i<2) delete endcapsidecoverot[i];
6708 }
6709 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6710 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6711 delete endcapcardsmatrix[0];
6712 return endcapassembly;
6713 }
6714 ////////////////////////////////////////////////////////////////////////////////
6715 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6716 Double_t radiusmax,
6717 Double_t width,
6718 Int_t ncables,
a6e0ebfe 6719 const char* volname){
9b0c60ab 6720 /////////////////////////////////////////////////////////////
6721 // Generating EndCap High Voltage Tubes
6722 /////////////////////////////////////////////////////////////
6723 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
60e55aee 6724 Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6725
9b0c60ab 6726 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6727 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6728 effectiveouteradius,0.5*width);
6729 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6730 effectiveinnertubeshape,
6731 fSSDStiffenerConnectorMedium);
6732 effectiveinnertube->SetLineColor(41);
6733 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6734 effectiveoutertubeshape,
6735 fSSDKaptonChipCableMedium);
6736 effectiveoutertube->SetLineColor(39);
6737 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6738 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6739 effectivemothertube->AddNode(effectiveinnertube,1);
6740 effectivemothertube->AddNode(effectiveoutertube,1);
6741 return effectivemothertube;
6742 }
6743 ////////////////////////////////////////////////////////////////////////////////
6744 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6745 /////////////////////////////////////////////////////////////
6746 // Generating EndCap Support Layer 5 and Layer 6
6747 /////////////////////////////////////////////////////////////
6748 const Int_t knedges = 5;
6749 ///////////////////////////////////////////////
6750 // Setting the vertices for TGeoXtru Up Volume
6751 ///////////////////////////////////////////////
6752 const Int_t klayernumber = 2;
6753 Double_t xupvertex[klayernumber][knedges+3];
6754 Double_t yupvertex[klayernumber][knedges+3];
6755 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6756 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6757 Double_t middlepsi[klayernumber] = {0.0,0.0};
6758 for(Int_t i=0; i<klayernumber; i++){
6759 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6760 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6761 xupvertex[i][2] = -xupvertex[i][1];
6762 xupvertex[i][3] = -xupvertex[i][0];
6763
6764 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6765 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6766 yupvertex[i][2] = yupvertex[i][1];
6767 yupvertex[i][3] = yupvertex[i][0];
6768
6769 middledgeangle[i] = upedgeangle[i]/knedges;
6770 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6771 for(Int_t j=1; j<knedges; j++){
6772 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6773 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6774 }
6775 }
6776 ////////////////////////////////////
6777 // Generating Up TGeoXtru
6778 ////////////////////////////////////
6779 TGeoXtru* upendcapsupportshape[klayernumber];
6780 TGeoVolume* upendcapsupport[klayernumber];
a3f8715e 6781 char upendcapsupportname[100];
9b0c60ab 6782 for(Int_t i=0; i<klayernumber; i++){
6783 upendcapsupportshape[i] = new TGeoXtru(2);
045be90c 6784 snprintf(upendcapsupportname,100,"UpEndCapSupportPieceLayer%i",i+5);
9b0c60ab 6785 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6786 upendcapsupportshape[i]->DefineSection(0,0.);
6787 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6788 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 6789 fSSDSupportRingAl);
9b0c60ab 6790 upendcapsupport[i]->SetLineColor(5);
6791 }
6792 ///////////////////////////////////////////////
6793 // Setting the vertices for TGeoXtru Down Volume
6794 ///////////////////////////////////////////////
6795 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6796 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6797 for(Int_t i=0; i<klayernumber; i++){
6798 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6799 xdownvertex[i][1] = xupvertex[i][0];
6800 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6801 ydownvertex[i][1] = yupvertex[i][0];
6802 for(Int_t j=0; j<knedges; j++){
6803 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6804 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6805 }
6806 for(Int_t j=0; j<knedges; j++){
6807 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6808 * CosD(middlepsi[i]+j*middledgeangle[i]);
6809 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6810 * SinD(middlepsi[i]+j*middledgeangle[i]);
6811 }
6812 }
6813 ////////////////////////////////////
6814 // Generating Down TGeoXtru
6815 ////////////////////////////////////
6816 TGeoXtru* downendcapsupportshape[klayernumber];
6817 TGeoVolume* downendcapsupport[klayernumber];
a3f8715e 6818 char downendcapsupportname[100];
9b0c60ab 6819 for(Int_t i=0; i<klayernumber; i++){
6820 downendcapsupportshape[i] = new TGeoXtru(2);
045be90c 6821 snprintf(downendcapsupportname,100,"DownEndCapSupportPieceLayer%i",i+5);
9b0c60ab 6822 downendcapsupportshape[i] = new TGeoXtru(2);
6823 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6824 if(i==0){
6825 downendcapsupportshape[i]->DefineSection(0,0.);
6826 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6827 }
6828 else{
6829 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6830 - fgkEndCapSupportLowWidth[i]);
6831 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6832 }
6833 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 6834 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 6835 downendcapsupport[i]->SetLineColor(5);
6836 }
6837 ///////////////////////////////////////////////
6838 // Setting TGeoPgon Volume
6839 ///////////////////////////////////////////////
6840 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6841 fgkSSDLay6LadderNumber};
6842 TGeoPgon* endcapsupportmothershape[klayernumber];
6843 TGeoVolume** endcapsupportmother;
6844 endcapsupportmother = new TGeoVolume*[klayernumber];
a3f8715e 6845 char endcapsupportmothername[100];
9b0c60ab 6846 for(Int_t i=0; i<klayernumber; i++){
6847 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
045be90c 6848 snprintf(endcapsupportmothername,100,"EndCapSupportMotherLayer%i",i+5);
9b0c60ab 6849 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6850 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6851 ydownvertex[i][0],yupvertex[i][1]);
6852 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 6853 fSSDAir);
9b0c60ab 6854 }
6855 ////////////////////////////////////
6856 TGeoRotation** endcapsupportrot[klayernumber];
6857 for(Int_t i=0; i<2; i++){
6858 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6859 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6860 endcapsupportrot[i][j] = new TGeoRotation();
6861 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6862 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6863 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6864 }
6865 }
6866 return endcapsupportmother;
6867 }
6868 ////////////////////////////////////////////////////////////////////////////////
6869 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6870 /////////////////////////////////////////////////////////////
6871 // Setting End Cap Support Layer 5 and 6.
6872 /////////////////////////////////////////////////////////////
6873 const Int_t kendcapcoverplatesmallholenumber = 9;
6874 const Int_t klayernumber = 2;
6875 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6876 fgkSSDLay6LadderNumber};
6877 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6878 360.0/kssdlayladdernumber[1]};
6879 TGeoVolume** endcapsupport = EndCapSupport();
6880 TGeoVolume** endcapassembly = GetEndCapAssembly();
6881 TGeoPgon* endcapsupportshape[klayernumber];
6882 Double_t* radiusmin[klayernumber];
6883 Double_t* radiusmax[klayernumber];
6884 for(Int_t i=0; i<klayernumber; i++){
6885 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6886 radiusmin[i] = endcapsupportshape[i]->GetRmin();
6887 radiusmax[i] = endcapsupportshape[i]->GetRmax();
6888 }
6889 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6890 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6891 endcapassemblyshape->GetDY(),
6892 endcapassemblyshape->GetDZ()};
6893 ///////////////////////////////////////////////
6894 // Setting TGeoPgon Volume for Mother Container
6895 ///////////////////////////////////////////////
6896 TGeoPgon* endcapsupportsystemshape[klayernumber];
a3f8715e 6897 char endcapsupportsystemothername[100];
9b0c60ab 6898 for(Int_t i=0; i<klayernumber; i++){
6899 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
045be90c 6900 snprintf(endcapsupportsystemothername,100,"EndCapSupportSystemLayer%i",i+5);
9b0c60ab 6901 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
6902 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
6903 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6904 +2.*endcapassemblycenter[2])
6905 /CosD(0.5*upedgeangle[i]));
6906 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
6907 -(fgkEndCapCoverPlateWidth[1]
6908 - fgkEndCapCoverPlateWidth[0]),
6909 *radiusmin[i],
6910 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6911 +2.*endcapassemblycenter[2])
6912 /CosD(0.5*upedgeangle[i]));
6913 }
e5bf64ae 6914 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 6915 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
6916 endcapsupportsystemshape[0],fSSDAir);
6917 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
6918 endcapsupportsystemshape[0],fSSDAir);
6919 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
6920 endcapsupportsystemshape[1],fSSDAir);
6921 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
6922 endcapsupportsystemshape[1],fSSDAir);
6923 ///////////////////////////////////////////////
6924 TGeoTranslation* endcapassemblytrans[klayernumber];
6925 for(Int_t i=0; i<klayernumber; i++)
6926 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
6927 - fgkEndCapSideCoverThickness
6928 + endcapassemblycenter[0],
6929 - 0.5*fgkEndCapCoverPlateThickness
6930 - 2.0*fgkEndCapCoolingTubeRadiusMax
6931 + 2.0*endcapassemblycenter[2]
6932 + 0.5*fgkEndCapSupportLength[i]
6933 / TanD(0.5*upedgeangle[i]),
6934 0.5*(fgkEndCapCoverPlateWidth[0]
6935 - fgkEndCapCoverPlateWidth[2]
6936 - (kendcapcoverplatesmallholenumber-1)
6937 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
6938 TGeoRotation** endcapassemblyrot[klayernumber];
6939 TGeoHMatrix** endcapassemblymatrix[klayernumber];
6940 for(Int_t i=0; i<klayernumber; i++){
6941 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
6942 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
6943 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
6944 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
6945 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
6946 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
6947 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
6948 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6949 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
6950 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
6951 }
6952 }
6953 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
6954 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
6955 for(Int_t i=0; i<2*klayernumber; i++){
6956 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
6957 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
6958 endcapassemblymatrix[1][j+2]);
6959 }
6960 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
6961 }
6962 /////////////////////////////////////////////////////////////
6963 // Deallocating memory
6964 /////////////////////////////////////////////////////////////
6965 for(Int_t i=0; i<klayernumber; i++){
6966 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
6967 delete endcapassemblyrot[i][j];
6968 }
7b208ef4 6969 delete [] endcapassemblyrot[i];
9b0c60ab 6970 delete endcapassemblymatrix[i][0];
6971 delete endcapassemblymatrix[i][1];
6972 }
6973 /////////////////////////////////////////////////////////////
6974 }
6975 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
6976 /////////////////////////////////////////////////////////////
6977 // Setting End Cap Support + End Cap Assembly of Layer 5.
6978 /////////////////////////////////////////////////////////////
6979 if (! moth) {
160835d5 6980 AliError("Can't insert end cap support of layer5, mother is null!\n");
9b0c60ab 6981 return;
6982 };
e5bf64ae 6983 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 6984 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
6985 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
6986 fgkEndCapSupportCenterLay5ITSPosition
6987 + fgkEndCapSupportCenterLay5Position
6988 - fgkEndCapSideCoverLength[2]);
6989 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
6990 fgkEndCapSideCoverLength[2]
6991 - fgkEndCapSupportCenterLay5Position
6992 - fgkEndCapSupportCenterLay5ITSPosition);
6993 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
6994 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
6995 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
6996 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
6997 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
6998 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
6999 /////////////////////////////////////////////////////////////
7000 // Deallocating memory
7001 /////////////////////////////////////////////////////////////
7002 delete endcapsupportsystemrot;
7003 delete endcapsupportsystemITSCentertrans[1];
7004 }
7005 /////////////////////////////////////////////////////////////
7006 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7007 /////////////////////////////////////////////////////////////
7008 // Setting End Cap Support + End Cap Assembly of Layer 6.
7009 /////////////////////////////////////////////////////////////
7010 if (! moth) {
160835d5 7011 AliError("Can't insert end cap support of layer6, mother is null!\n");
9b0c60ab 7012 return;
7013 };
e5bf64ae 7014 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7015 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7016 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7017 fgkEndCapSupportCenterLay6ITSPosition
7018 + fgkEndCapSupportCenterLay6Position
7019 - fgkEndCapSideCoverLength[2]);
7020 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7021 fgkEndCapSideCoverLength[2]
7022 - fgkEndCapSupportCenterLay6Position
7023 - fgkEndCapSupportCenterLay6ITSPosition);
7024 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7025 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7026 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7027 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7028 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7029 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7030 /////////////////////////////////////////////////////////////
7031 // Deallocating memory
7032 /////////////////////////////////////////////////////////////
7033 delete endcapsupportsystemrot;
7034 delete endcapsupportsystemITSCentertrans[1];
7035 }
7036 ////////////////////////////////////////////////////////////////////////////////
7037 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7038 /////////////////////////////////////////////////////////////
7039 // Setting Ladder Support of Layer 5.
7040 /////////////////////////////////////////////////////////////
7041 if (! moth) {
160835d5 7042 AliError("Can't insert ladder lupport of layer5, mother is null!\n");
9b0c60ab 7043 return;
7044 };
7045 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7046 fMotherVol = moth;
7047 TGeoTranslation* centerITSRingSupportLay5trans[2];
7048 for(Int_t i=0; i<2; i++){
7049 centerITSRingSupportLay5trans[i] =
7050 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7051 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7052 }
7053 }
7054 ////////////////////////////////////////////////////////////////////////////////
7055 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7056 /////////////////////////////////////////////////////////////
7057 // Setting Ladder Support of Layer 6.
7058 /////////////////////////////////////////////////////////////
7059 if (! moth) {
160835d5 7060 AliError("Can't insert ladder lupport of layer6, mother is null!\n");
9b0c60ab 7061 return;
7062 };
7063 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7064 fMotherVol = moth;
7065 TGeoTranslation* centerITSRingSupportLay6trans[2];
7066 for(Int_t i=0; i<2; i++){
7067 centerITSRingSupportLay6trans[i] =
7068 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7069 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7070 }
7071 }
7072 ////////////////////////////////////////////////////////////////////////////////
47f8de53 7073 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7074 /////////////////////////////////////////////////////////////
7075 // Setting Ladder Support of Layer 6.
7076 /////////////////////////////////////////////////////////////
7077 if (! moth) {
160835d5 7078 AliError("Can't insert SSD Cone, mother is null!\n");
47f8de53 7079 return;
7080 };
7081 if(!fSSDCone) SetSSDCone();
7082 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7083 + fgkSSDCentralAL3SupportLength);
7084 moth->AddNode(fSSDCone,1,ssdconetrans);
7085}
7086 ////////////////////////////////////////////////////////////////////////////////
7087 void AliITSv11GeometrySSD::SetSSDCone(){
7088 /////////////////////////////////////////////////////////////
7089 // Method generating SSDCone
7090 /////////////////////////////////////////////////////////////
7091 if(!fCreateMaterials) CreateMaterials();
7092 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7093 Double_t ssdpconesectionradiusmax[16];
7094 Double_t ssdpconesectionradiusmin[16];
7095 Double_t ssdpconezsection[16];
7096 TGeoPcon* ssdpconelittleholeshape[8];
7097 TGeoVolume* ssdpconelittlehole[8];
7098 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7099 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7100 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7101 / SinD(fgkSSDPConeAngle)
7102 + ssdpconesectionradiusmin[0];
7103 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7104 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7105 / SinD(fgkSSDPConeAngle);
7106 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7107 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7108 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7109 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7110 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7111 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7112 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7113 ssdpconelittlehole[0]->SetLineColor(4);
7114 /////////////////////////////////////////////////////////////
7115 ssdpconezsection[2] = ssdpconezsection[1];
7116 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7117 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7118 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7119 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7120 / SinD(fgkSSDPConeAngle);
7121 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7122 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7123 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7124 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7125 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7126 * TMath::RadToDeg();
7127 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7128 60.-ssdpconelittleholeangle,2);
7129 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7130 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7131 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7132 ssdpconelittlehole[1]->SetLineColor(4);
7133 TGeoRotation* ssdconelittleholerot[6];
7134 for(Int_t i=0; i<6; i++){
7135 ssdconelittleholerot[i] = new TGeoRotation();
7136 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7137 }
7138 /////////////////////////////////////////////////////////////
7139 ssdpconezsection[4] = ssdpconezsection[3];
7140 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7141 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7142 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7143 * CosD(fgkSSDPConeAngle)
7144 / SinD(fgkSSDPConeAngle);
7145 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7146 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7147 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7148 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7149 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7150 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7151 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7152 ssdpconelittlehole[2]->SetLineColor(4);
7153 ///////////////////////////////////////////////////
7154 ssdpconezsection[6] = ssdpconezsection[5];
7155 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7156 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7157 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7158 -ssdpconezsection[0]
7159 * CosD(fgkSSDPConeAngle)
7160 / SinD(fgkSSDPConeAngle);
7161 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7162 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7163 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7164 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7165 * TMath::RadToDeg();
7166 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7167 45.-ssdpconemiddleholeangle,2);
7168 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7169 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7170 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7171 ssdpconelittlehole[3]->SetLineColor(4);
7172 TGeoRotation* ssdconemiddleholerot[8];
7173 for(Int_t i=0; i<8; i++){
7174 ssdconemiddleholerot[i] = new TGeoRotation();
7175 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7176 }
7177 /////////////////////////////////////////////////////////////
7178 ssdpconezsection[8] = ssdpconezsection[7];
7179 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7180 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7181 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7182 * CosD(fgkSSDPConeAngle)
7183 / SinD(fgkSSDPConeAngle);
7184 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7185 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7186 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7187 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7188 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7189 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7190 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7191 ssdpconelittlehole[4]->SetLineColor(4);
7192 /////////////////////////////////////////////////////////////
7193 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7194 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7195 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7196 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7197 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7198 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7199 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7200 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7201 * TMath::RadToDeg();
7202 ssdpconezsection[10] = ssdpconezsection[9];
7203 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7204 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7205 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7206 * CosD(fgkSSDPConeAngle)
7207 / SinD(fgkSSDPConeAngle);
7208 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7209 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7210 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7211 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7212 ssdpconetrapezoidsectionangle,2);
7213 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7214 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7215 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7216 ssdpconelittlehole[5]->SetLineColor(4);
7217 TGeoRotation* ssdconeupradiusrot[8];
7218 for(Int_t i=0; i<8; i++){
7219 ssdconeupradiusrot[i] = new TGeoRotation();
7220 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7221 }
7222 /////////////////////////////////////////////////////////////
7223 ssdpconezsection[12] = ssdpconezsection[11];
7224 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7225 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7226 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7227 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7228 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7229 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7230 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7231 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7232 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7233 ssdpconelittlehole[6]->SetLineColor(4);
7234 /////////////////////////////////////////////////////////////
7235 ssdpconezsection[14] = 0.0;
7236 ssdpconezsection[15] = ssdpconezsection[0];
7237 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7238 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7239 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7240 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7241 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7242 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7243 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7244 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7245 ssdpconelittlehole[7]->SetLineColor(4);
7246 /////////////////////////////////////////////////////////////
7247 TGeoTube* ssdtubeconeshape[2];
7248 TGeoVolume* ssdtubecone[2];
7249 TGeoTranslation* ssdtubeconetrans[2];
7250 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7251 fgkSSDPConeExternalRadius,
7252 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7253 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7254 0.5*ssdpconezsection[0]);
7255 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7256 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7257 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7258 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7259 + ssdpconezsection[13]);
7260 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7261 ssdtubecone[0]->SetLineColor(4);
7262 ssdtubecone[1]->SetLineColor(4);
7263 /////////////////////////////////////////////////////////////
7264 // Mother Volume Container
7265 /////////////////////////////////////////////////////////////
7266 Double_t ssdconemotherradiusmin[8];
7267 Double_t ssdconemotherradiusmax[8];
7268 Double_t ssdconemothersection[8];
7269 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7270 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7271 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7272 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7273 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7274 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7275 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7276 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7277 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7278 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7279 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7280 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7281 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7282 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7283 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7284 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7285 ssdconemothersection[0] = 0.0;
7286 ssdconemothersection[1] = ssdpconezsection[0];
7287 ssdconemothersection[2] = ssdpconezsection[0];
7288 ssdconemothersection[3] = ssdpconezsection[11];
7289 ssdconemothersection[4] = ssdpconezsection[11];
7290 ssdconemothersection[5] = ssdpconezsection[13];
7291 ssdconemothersection[6] = ssdpconezsection[13];
7292 ssdconemothersection[7] = fgkSSDPConeLength;
7293 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7294 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7295 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7296 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7297 /////////////////////////////////////////////////////////////
7298 //Placing the Volumes into Mother
7299 /////////////////////////////////////////////////////////////
7300 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7301 for(Int_t i=0; i<6; i++){
7302 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7303 }
7304 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7305 for(Int_t i=0; i<8; i++){
7306 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7307 }
7308 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7309 for(Int_t i=0; i<8; i++){
7310 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7311 }
7312 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7313 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7314 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7315 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7316 /////////////////////////////////////////////////////////////
7317 // ITS General Support
7318 /////////////////////////////////////////////////////////////
7319 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7320 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7321 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7322 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7323 - fgkSSDCentralAL3SupportLength);
7324 ssdcentralsupport->SetLineColor(4);
7325 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7326 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7327 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7328 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7329 TGeoTranslation* ssdcentralal3supportrans[3];
7330 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7331 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7332 - 1.25*fgkSSDCentralAL3SupportLength);
7333 ssdcentralal3support->SetLineColor(4);
7334 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7335 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7336 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7337 Double_t ssdpconcentralradiusmin[2];
7338 Double_t ssdpconcentralradiusmax[2];
7339 Double_t ssdpconcentralsection[2];
7340 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7341 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7342 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7343 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7344 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7345 ssdpconcentralsection[1] = 0.;
7346 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7347 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7348 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7349 ssdpconcentralal3->SetLineColor(4);
7350 fSSDCone->AddNode(ssdpconcentralal3,1);
7351 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7352 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7353 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7354 -2.*fgkSSDCentralAL3SupportLength);
7355 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7356 *ssdcentralal3supportrot);
7357 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7358 TGeoRotation* ssdconemotherot = new TGeoRotation();
7359 ssdconemotherot->SetAngles(90.,180.,-90.);
7360 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7361 -2.*fgkSSDCentralAL3SupportLength);
7362 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7363 fSSDCone->AddNode(ssdconemother,1);
7364 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7365 /////////////////////////////////////////////////////////////
7366 // Deallocating memory
7367 /////////////////////////////////////////////////////////////
7368 delete ssdcentralal3supportrot;
7369 delete ssdcentralal3supportrans[2];
7370 delete ssdconemotherot;
7371 delete ssdconemothertrans;
7372 /////////////////////////////////////////////////////////////
7373 }
fcfbdd23 7374 ////////////////////////////////////////////////////////////////////////////////
7375 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7376 /////////////////////////////////////////////////////////////
7377 // Setting SSD Cables
7378 /////////////////////////////////////////////////////////////
7379 if (! moth) {
160835d5 7380 AliError("Can't insert SSD Cables, mother is null!\n");
fcfbdd23 7381 return;
7382 };
7383 TGeoVolume* ssdcables = SetSSDCables();
7384 moth->AddNode(ssdcables,1);
7385}
47f8de53 7386 ////////////////////////////////////////////////////////////////////////////////
7387 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
f7cd318e 7388 /////////////////////////////////////////////////////////////
7389 // Method generating SSDCables
7390 /////////////////////////////////////////////////////////////
7391
7392 /////////////////////////////////////////////////////////////////////////////////
7393 // SSD Cables Parameters (lengths are in mm and angles in degrees)
7394 /////////////////////////////////////////////////////////////////////////////////
7395
7396 const Double_t kSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
7397 const Double_t kSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
7398
7399 // Cable thickness for rings at outer Z
7400 // Average: 9/2 = 4.5 cables per quadrant
7401 // 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
7402
7403 const Double_t kSSDCablesLay5RingArea = 21.*34./8.*fgkmm*fgkmm; // to be fixed in order to reproduce material budget
7404 const Double_t kSSDCablesLay6RingArea = 21.*38./8.*fgkmm*fgkmm; // to be fixed in order to reproduce material budget
7405
7406
7407 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
7408
7409 const Double_t kSSDCableAngle = 22.5;
7410 // MvL: remove water?
7411 const Double_t kSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm; // to be fixed in order to reproduce material budget
7412 const Double_t kSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
7413 const Double_t kSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
7414 const Double_t kSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
7415 const Double_t kSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
7416 const Double_t kSSDPatchPanel2RB26Radius = 451.3*fgkmm;
7417 const Double_t kSSDPatchPanel2RB24Radius = 451.3*fgkmm;
7418 const Double_t kSSDPatchPanelHeight = 87.5*fgkmm;
7419
7420 // SSD Layer 5 Cables
7421 //////////////////////////////////////////////////////////////////////////////////////////////////
7422 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7423 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
7424 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
7425 //////////////////////////////////////////////////////////////////////////////////////////////////
7426 // Printf(Form("Cable ring: rad min: %g length %g thick %g", ssdcableslay5rigthsideradiusmin, ssdcablelay5rightsidelength, kSSDCablesLay5RingArea/ssdcablelay5rightsidelength));
7427
7428
7429
47f8de53 7430 ////////////////////////////////////
7431 // Double_t cablescapacity[20];
7432 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7433 ////////////////////////////////////
f7cd318e 7434 //ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
47f8de53 7435 ////////////////////////////////////
7436 // TGeoPCone Volumes
7437 ///////////////////////////////////
7438 TGeoPcon* ssdcableslay5pconshape[3];
7439 TGeoVolume* ssdcableslay5pcon[3];
7440 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7441 Double_t ssdcableslay5pconzsection[6];
7442 Double_t ssdcableslay5pconrmin[6];
7443 Double_t ssdcableslay5pconrmax[6];
f7cd318e 7444 ssdcableslay5pconrmin[0] = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
47f8de53 7445 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
f7cd318e 7446
47f8de53 7447 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
f7cd318e 7448 + fgkEndCapSupportCenterLay5Position;
7449 //+ 2.*ssdcablelay5rightsidelength; // removing this generates overlap with the water ring
7450 // Keeping it generates overlap with the cones...
7451 // SSDCables/SSDCableLay5RightSideWaterTube_2 ovlp=0.0939792
47f8de53 7452 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7453 + fgkSSDCentralAL3SupportLength
7454 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7455 * TanD(fgkSSDPConeAngle);
f7cd318e 7456 Double_t dz = ssdcableslay5pconzsection[1]-ssdcableslay5pconzsection[0];
7457 Double_t pconethickness = kSSDCablesLay5RingArea/TMath::Abs(dz);
7458 ssdcableslay5pconrmax[0] = ssdcableslay5pconrmin[0]+pconethickness;
7459 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+pconethickness;
7460 //Printf(Form("pcone: r1 %g r2 %g z1 %g z2 %g thickness %g", ssdcableslay5pconrmax[0], ssdcableslay5pconrmax[1],
7461 // ssdcableslay5pconzsection[0],ssdcableslay5pconzsection[1],pconethickness));
7462
47f8de53 7463 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7464 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7465 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7466 ssdcableslay5pconshape[0],fSSDCopper);
7467 ssdcableslay5pcon[0]->SetLineColor(9);
7468 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
f7cd318e 7469
7470 Double_t totvol = ssdcableslay5pcon[0]->Capacity();
7471 // Printf(Form("Cables, lay5, pCone,volume: %g", ssdcableslay5pcon[0]->Capacity()));
47f8de53 7472////////////////////////////////////
7473// cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7474////////////////////////////////////
f7cd318e 7475
7476 //
7477 // PCon 2 and 3 are cables going through/towards holes in supports
7478 //
47f8de53 7479 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7480 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7481 + fgkSSDCentralAL3SupportLength
7482 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7483 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7484 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7485 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7486 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
f7cd318e 7487 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7488 ssdcableangle,2);
7489 // Printf(Form("PCon2, phi %g dphi %g ",90.0-kSSDCableAngle-0.5*ssdcableangle, ssdcableangle));
47f8de53 7490 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
f7cd318e 7491 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
47f8de53 7492 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7493 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7494 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
f7cd318e 7495 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3] + kSSDCablesHeight;
47f8de53 7496 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7497 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7498 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7499 ssdcableslay5pcon[1]->SetLineColor(9);
7500 ////////////////////////////////////
f7cd318e 7501 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7502 ssdcableangle,2);
7503 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7504 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7505 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7506 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7507 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7508 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7509 * TanD(fgkSSDPConeAngle)
7510 + 0.5*fgkSSDCentralSupportLength
7511 + fgkSSDCentralAL3SupportLength;
7512 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7513 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7514 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7515 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7516 ssdcableslay5pcon[2]->SetLineColor(9);
7517////////////////////////////////////
7518 TGeoRotation* ssdcableslay5pconrot[4];
7519 for(Int_t i=0; i<4; i++){
7520 ssdcableslay5pconrot[i] = new TGeoRotation();
7521 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7522 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7523 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
f7cd318e 7524 // Printf(Form("Pcon2, Pcon3, vol %g %g",ssdcableslay5pcon[1]->Capacity(),ssdcableslay5pcon[2]->Capacity()));
7525 totvol += ssdcableslay5pcon[1]->Capacity()+ssdcableslay5pcon[2]->Capacity();
47f8de53 7526 }
7527 ////////////////////////////////////
7528 //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7529 //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7530 ////////////////////////////////////
7531 // Positioning Left SSD Cables Part
7532 ////////////////////////////////////
47f8de53 7533 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7534 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7535 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7536 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7537 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7538 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7539 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7540 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7541 }
7542 ////////////////////////////////////
7543 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7544 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7545 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7546 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7547 /////////////////////////////////////////////////////////////
7548 // Water Tubes Layer 5
7549 /////////////////////////
f7cd318e 7550 /* Remove ring; could be replaced with a PCone next to/on top of the cables
7551
7552 //
7553 // MvL: Remove ring; put everything in PCone
7554 //
7555 // Need to keep dimensions for water ring...
7556
7557 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7558
7559 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
7560 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7561 - fgkSSDLowerPConeRadius)
7562 * TanD(fgkSSDPConeAngle);
7563 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7564 + fgkEndCapSupportCenterLay5Position
7565 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7566 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7567 - ssdcableslay5startconedistance;
7568 ssdcablelay5rightsidelength *= ssdcablesfactor;
7569 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+kSSDCablesLay5RingArea/ssdcablelay5rightsidelength;
7570
7571
7572 TGeoTranslation* ssdcablelay5rightrans =
7573 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7574 + fgkEndCapSupportCenterLay5Position
7575 + 0.5*ssdcablelay5rightsidelength);
7576
7577 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7578 - 0.5*ssdcablelay5rightsidelength
7579 - fgkEndCapSupportCenterLay5Position
7580 - fgkEndCapSupportCenterLay5ITSPosition);
7581
47f8de53 7582 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7583 ssdcableslay5rightsideradiusmax
f7cd318e 7584 + kSSDCablesLay5RightSideWaterHeight,
47f8de53 7585 0.5*ssdcablelay5rightsidelength);
7586 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7587 ssdcablelay5rightubewatershape,
7588 fSSDCoolingTubeWater);
7589 ssdcablelay5rightwatertube->SetLineColor(7);
7590 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7591 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
f7cd318e 7592 */
47f8de53 7593 ////////////////////////////////////
7594 // TGeoPCone Water Volumes Layer
7595 ///////////////////////////////////
7596 TGeoPcon* ssdcableslay5pconwatershape[3];
7597 TGeoVolume* ssdcableslay5pconwater[3];
7598 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7599 Double_t ssdcableslay5pconwaterzsection[6];
7600 Double_t ssdcableslay5pcwateronrmin[6];
7601 Double_t ssdcableslay5pconwaterrmax[6];
7602 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7603 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
f7cd318e 7604 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7605 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7606 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
f7cd318e 7607 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7608 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7609 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7610 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7611 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7612 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7613 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7614 ssdcableslay5pconwater[0]->SetLineColor(7);
7615 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7616 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7617////////////////////////////////////
7618 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7619 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
f7cd318e 7620 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7621 ssdcableangle,2);
7622 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7623 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
f7cd318e 7624 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7625 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7626 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
f7cd318e 7627 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7628 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7629 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7630 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7631 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7632 ssdcableslay5pconwater[1]->SetLineColor(7);
7633////////////////////////////////////
f7cd318e 7634 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7635 ssdcableangle,2);
7636 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7637 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
f7cd318e 7638 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7639 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7640 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
f7cd318e 7641 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7642 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7643 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7644 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7645 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7646 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7647 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7648 ssdcableslay5pconwater[2]->SetLineColor(7);
7649////////////////////////////////////
7650 TGeoRotation* ssdcableslay5pconwaterot[4];
7651 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7652 for(Int_t i=0; i<4; i++){
7653 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7654 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7655 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7656 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7657 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7658 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7659 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7660 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7661 }
7662 /////////////////////////
7663 // SSD Layer 6 Cables
7664 /////////////////////////
f7cd318e 7665 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+kSSDCablesLay6TubeRadiusMin;
7666 Double_t ssdcablelay6rightsidelength = 2.; // cm was 2.*ssdcablelay5rightsidelength;
7667 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+kSSDCablesLay6RingArea/ssdcablelay6rightsidelength;
7668 // Printf(Form("Lay 6 cables, length %g, radius %g, thickness %g", ssdcablelay6rightsidelength, ssdcableslay6rigthsideradiusmin, kSSDCablesLay6RingArea/ssdcablelay6rightsidelength));
47f8de53 7669 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7670 ssdcableslay6rightsideradiusmax,
7671 0.5*ssdcablelay6rightsidelength);
7672 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7673 ssdcablelay6rightubeshape,
7674 fSSDCopper);
7675 ssdcablelay6righttube->SetLineColor(9);
7676 TGeoTranslation* ssdcablelay6rightrans =
7677 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7678 + fgkEndCapSupportCenterLay6Position
7679 + 0.5*ssdcablelay6rightsidelength);
7680 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7681 - 0.5*ssdcablelay6rightsidelength
7682 - fgkEndCapSupportCenterLay6Position
7683 - fgkEndCapSupportCenterLay6ITSPosition);
7684 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7685 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
f7cd318e 7686 // Printf(Form("Cables; ring layer 6, volume: %g",ssdcablelay6rightubeshape->Capacity()));
7687 totvol += ssdcablelay6rightubeshape->Capacity();
47f8de53 7688 ////////////////////////////////////
7689 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7690 ////////////////////////////////////
f7cd318e 7691 // MvL: PCon is part of connection to patch panels;
7692 // removed since current volume is too thick; now absorbed in rings+connections
7693 /*
7694 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7695 ssdcableangle,2);
7696 TGeoVolume* ssdcableslay6pcon;
7697 Double_t ssdcableslay6pconrmin[2];
7698 Double_t ssdcableslay6pconrmax[2];
7699 Double_t ssdcableslay6pconzsection[2];
7700 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7701 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7702 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7703 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7704 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7705 + fgkEndCapSupportCenterLay6Position
7706 + ssdcablelay6rightsidelength;
7707 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7708 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7709 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
f7cd318e 7710
47f8de53 7711 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7712 ssdcableslay6pconshape,fSSDCopper);
7713 ssdcableslay6pcon->SetLineColor(9);
7714 for(Int_t i=0; i<4; i++){
7715 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7716 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7717 }
f7cd318e 7718 */
47f8de53 7719 ////////////////////////////////////
7720 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7721 /////////////////////////
7722 // Water Tubes Layer 6
7723 /////////////////////////
7724 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7725 ssdcableslay6rightsideradiusmax
f7cd318e 7726 + kSSDCablesLay5RightSideWaterHeight,
47f8de53 7727 0.5*ssdcablelay6rightsidelength);
7728 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7729 ssdcablelay6righwatertubeshape,
7730 fSSDCoolingTubeWater);
7731 ssdcablelay6rightwatertube->SetLineColor(7);
7732 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7733 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
f7cd318e 7734 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7735 ssdcableangle,2);
7736 TGeoVolume* ssdcableslay6waterpcon;
7737 Double_t ssdcableslay6waterpconrmin[2];
7738 Double_t ssdcableslay6waterpconrmax[2];
7739 Double_t ssdcableslay6waterpconzsection[2];
7740 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7741 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
f7cd318e 7742 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7743 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7744 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7745 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7746 + fgkEndCapSupportCenterLay6Position
7747 + ssdcablelay6rightsidelength;
7748 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7749 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7750 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7751 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7752 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7753 ssdcableslay6waterpcon->SetLineColor(7);
7754 TGeoRotation* ssdcableslay6pconwaterot[4];
7755 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7756 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7757 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7758 for(Int_t i=0; i<4; i++){
7759 ssdcableslay6pconwaterot[i] = new TGeoRotation();
7760 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7761 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7762 * (*ssdcableslay6pconwaterot[i]));
7763 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7764 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7765 }
7766 ////////////////////////////////////////
7767 // From ITS Ring to Patch Panel3-RB26
7768 ////////////////////////////////////////
7769 Double_t ssdcablepatchpanel3BB26radiusmin[2];
7770 Double_t ssdcablepatchpanel3BB26radiusmax[2];
7771 Double_t ssdcablepatchpanel3RB26zsection[2];
f7cd318e 7772 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*kSSDPatchPanelHeight;// +2.8+0.003;//Avoid small overlap with SPDshieldring;
47f8de53 7773 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
f7cd318e 7774 + kSSDCablesHeight;
7775 ssdcablepatchpanel3BB26radiusmin[1] = kSSDPatchPanel2RB26Radius;
47f8de53 7776 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
f7cd318e 7777 + kSSDCablesHeight;
47f8de53 7778 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
f7cd318e 7779 + fgkSSDCentralAL3SupportLength
47f8de53 7780 + fgkSSDPConeZLength[0];
f7cd318e 7781 ssdcablepatchpanel3RB26zsection[1] = kSSDPatchPanel2RB26ITSDistance;
7782 // Printf(Form("RB26 cable length %g",ssdcablepatchpanel3RB26zsection[1]-ssdcablepatchpanel3RB26zsection[0]));
7783 // Printf(Form("Angular range %g",ssdcableangle));
7784
47f8de53 7785 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
f7cd318e 7786 new TGeoPcon(90.0-kSSDCablesPatchPanel2RB26Angle[0]
47f8de53 7787 - 0.5*ssdcableangle,ssdcableangle,2);
7788 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7789 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7790 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7791 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7792 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
85f741d8 7793 TGeoRotation* ssdcablepatchpanel3B26rot[4];
47f8de53 7794 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
67446e8a 7795 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
f7cd318e 7796 ssdcablepatchpanel3B26rot[1]->SetAngles(kSSDCablesPatchPanel2RB26Angle[0]
7797 + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
67446e8a 7798 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
f7cd318e 7799 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0 + kSSDCablesPatchPanel2RB26Angle[0]
7800 + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
47f8de53 7801 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
f7cd318e 7802 // Printf(Form("Cable to patch panels RB26 volume: %g (x4)",ssdcablepatchpanel3RB26pcon->Capacity()));
47f8de53 7803 ////////////////////////////////////
7804 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7805 ////////////////////////////////////////
7806 // ITS Ring Cables RB26 Part
7807 ////////////////////////////////////////
7808 Double_t ssdcableitsring3BB26pconzsection[2];
7809 Double_t ssdcableitsring3BB26pconrmin[2];
7810 Double_t ssdcableitsring3BB26pconrmax[2];
7811 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7812 + fgkSSDCentralAL3SupportLength
7813 + (4.0/5.0)*fgkSSDPConeZLength[0];
7814 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
f7cd318e 7815 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
7816 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0] + 2.5*kSSDCablesHeight; // widths of cable bunch is about half of patch panels; need factor 2.5
7817
47f8de53 7818 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7819 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7820 TGeoPcon* ssdcableitsring3BB26pconshape[4];
f7cd318e 7821 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0 - kSSDCablesPatchPanel2RB26Angle[0]
47f8de53 7822 - 0.5*ssdcableangle,ssdcableangle
f7cd318e 7823 + (kSSDCablesPatchPanel2RB26Angle[0]
7824 - kSSDCableAngle),2);
7825 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0 + kSSDCablesPatchPanel2RB26Angle[1]
47f8de53 7826 - 0.5*ssdcableangle,ssdcableangle
f7cd318e 7827 + 3.0*kSSDCableAngle
7828 - kSSDCablesPatchPanel2RB26Angle[1],2);
7829 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-kSSDCablesPatchPanel2RB26Angle[0]
47f8de53 7830 - 0.5*ssdcableangle,ssdcableangle
f7cd318e 7831 - kSSDCableAngle
7832 + kSSDCablesPatchPanel2RB26Angle[0],2);
7833 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+kSSDCablesPatchPanel2RB26Angle[1]
47f8de53 7834 - 0.5*ssdcableangle,ssdcableangle
f7cd318e 7835 + 3.0*kSSDCableAngle
7836 - kSSDCablesPatchPanel2RB26Angle[1],2);
47f8de53 7837 for(Int_t i=0;i<4;i++)
7838 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7839 ssdcableitsring3BB26pconrmin[j],
7840 ssdcableitsring3BB26pconrmax[j]);
7841 TGeoVolume* ssdcableitsring3BB26pcon[4];
7842 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7843 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7844 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7845 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7846 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7847 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7848 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7849 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7850 for(Int_t i=0;i<4;i++){
7851 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
5ef8864c 7852 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
f7cd318e 7853 //Printf(Form("Cable to patch panels RB26 volume part 2: %g (%d)",ssdcableitsring3BB26pcon[i]->Capacity(),i));
47f8de53 7854}
f7cd318e 7855
47f8de53 7856 ////////////////////////////////////
7857 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7858 // + ssdcableitsring3BB26pconshape[1]->Capacity()
7859 // + ssdcableitsring3BB26pconshape[2]->Capacity()
7860 // + ssdcableitsring3BB26pconshape[3]->Capacity();
7861 ////////////////////////////////////////
7862 // From ITS Ring to Patch Panel2-RB24
7863 ////////////////////////////////////////
7864 Double_t ssdcablepatchpanel3BB24radiusmin[2];
7865 Double_t ssdcablepatchpanel3BB24radiusmax[2];
7866 Double_t ssdcablepatchpanel3RB24zsection[2];
7867 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7868 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
f7cd318e 7869 ssdcablepatchpanel3BB24radiusmin[1] = kSSDPatchPanel2RB24Radius;
47f8de53 7870 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
f7cd318e 7871 + kSSDCablesHeight;
47f8de53 7872 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7873 - fgkSSDCentralAL3SupportLength
7874 - fgkSSDPConeZLength[0];
f7cd318e 7875 ssdcablepatchpanel3RB24zsection[1] = -kSSDPatchPanel2RB24ITSDistance;
7876 //Printf(Form("RB24 cable length %g",ssdcablepatchpanel3RB24zsection[1]-ssdcablepatchpanel3RB24zsection[0]));
47f8de53 7877 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
f7cd318e 7878 new TGeoPcon(90.0-kSSDCablesPatchPanel2RB24Angle[1]
47f8de53 7879 - 0.5*ssdcableangle,ssdcableangle,2);
7880 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7881 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7882 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7883 ssdcablepatchpanel3RB24pconshape,
7884 fSSDCopper);
7885 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
85f741d8 7886 TGeoRotation* ssdcablepatchpanel3B24rot[4];
47f8de53 7887 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
67446e8a 7888 ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
f7cd318e 7889 ssdcablepatchpanel3B24rot[1]->SetAngles(kSSDCablesPatchPanel2RB24Angle[0]
7890 + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
67446e8a 7891 ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
f7cd318e 7892 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+kSSDCablesPatchPanel2RB24Angle[0]
7893 + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
47f8de53 7894 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
f7cd318e 7895 //Printf(Form("Cable to patch panels RB24 volume: %g (x4)",ssdcablepatchpanel3RB24pcon->Capacity()));
47f8de53 7896 ////////////////////////////////////
7897 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7898 ////////////////////////////////////////
7899 // ITS Ring Cables RB24 Part
7900 ////////////////////////////////////////
7901 Double_t ssdcableitsring3BB24pconzsection[2];
7902 Double_t ssdcableitsring3BB24pconrmin[2];
7903 Double_t ssdcableitsring3BB24pconrmax[2];
7904 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7905 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
f7cd318e 7906 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
7907 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0] + 2.5*kSSDCablesHeight; // Cable bunch width smaller; make it thicker
7908
47f8de53 7909 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
7910 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
7911 TGeoPcon* ssdcableitsring3BB24pconshape[4];
f7cd318e 7912 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7913 + (90.0-kSSDCablesPatchPanel2RB24Angle[1]
7914 - kSSDCableAngle),2);
7915 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+kSSDCableAngle-0.5*ssdcableangle,
7916 ssdcableangle-kSSDCableAngle
7917 + kSSDCablesPatchPanel2RB24Angle[0],2);
7918 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7919 - kSSDCableAngle
7920 + 90.0 - kSSDCablesPatchPanel2RB24Angle[1],2);
7921 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+kSSDCableAngle-0.5*ssdcableangle,
7922 ssdcableangle-kSSDCableAngle
7923 + kSSDCablesPatchPanel2RB24Angle[0],2);
47f8de53 7924 for(Int_t i=0;i<4;i++)
7925 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
7926 ssdcableitsring3BB24pconrmin[j],
7927 ssdcableitsring3BB24pconrmax[j]);
7928 TGeoVolume* ssdcableitsring3BB24pcon[4];
7929 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
7930 ssdcableitsring3BB24pconshape[0],fSSDCopper);
7931 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
7932 ssdcableitsring3BB24pconshape[1],fSSDCopper);
7933 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
7934 ssdcableitsring3BB24pconshape[2],fSSDCopper);
7935 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
7936 ssdcableitsring3BB24pconshape[3],fSSDCopper);
7937 for(Int_t i=0;i<4;i++){
7938 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
5ef8864c 7939 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
f7cd318e 7940 // Printf(Form("Cable to patch panels RB24 (part 2) volume: %g (%d)",ssdcableitsring3BB24pcon[i]->Capacity(),i));
47f8de53 7941}
f7cd318e 7942
47f8de53 7943 ////////////////////////////////////
7944 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
7945 // + ssdcableitsring3BB24pconshape[1]->Capacity()
7946 // + ssdcableitsring3BB24pconshape[2]->Capacity()
7947 // + ssdcableitsring3BB24pconshape[3]->Capacity();
47f8de53 7948
f7cd318e 7949 // MvL: Pcon are connection to patch panels (part of)
7950 // Removed; do not contribute much; put into ring structure
7951 /*
47f8de53 7952 TGeoPcon* ssdcablelay6materialbudgetpconshape =
f7cd318e 7953 new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
47f8de53 7954 TGeoVolume* ssdcablelay6materialbudgetpcon;
7955 Double_t ssdcablelay6materialbudgetpconrmin[2];
7956 Double_t ssdcablelay6materialbudgetpconrmax[2];
7957 Double_t ssdcablelay6materialbudgetpconzsection[2];
7958 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
f7cd318e 7959 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7960 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
f7cd318e 7961 + kSSDCableMaterialBudgetHeight;
47f8de53 7962 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
7963 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
7964 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7965 + fgkEndCapSupportCenterLay6Position
7966 + ssdcablelay6rightsidelength;
7967 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7968 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
7969 ssdcablelay6materialbudgetpconzsection[i],
7970 ssdcablelay6materialbudgetpconrmin[i],
7971 ssdcablelay6materialbudgetpconrmax[i]);
7972 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
7973 ssdcablelay6materialbudgetpconshape,fSSDCopper);
7974 ssdcablelay6materialbudgetpcon->SetLineColor(9);
7975 for(Int_t i=0; i<4; i++){
7976 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
7977 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7978 }
f7cd318e 7979 */
47f8de53 7980////////////////////////////////////
7981 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
7982 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
7983 Double_t ssdcablesvolume = 0.0;
7984 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
7985 std::cout << ssdcablesvolume << std::endl;*/
f7cd318e 7986 // Printf(Form("Total volume (one side; without conn to patch panel): %g",totvol));
47f8de53 7987 return ssdcablesmother;
7988 }
7989 ////////////////////////////////////////////////////////////////////////////////
277f0a14 7990TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3 const * const vertexpos[4] , const Double_t* width,
b671cde1 7991 Double_t height, const char* shapename, Int_t isign) const{
44285dfa 7992 /////////////////////////////////////////////////////////////
7993 // Method generating an Arb shape
7994 /////////////////////////////////////////////////////////////
7995 const Int_t kvertexnumber = 8;
7996 const Int_t ktransvectnumber = 2;
b671cde1 7997 TVector3 vertex[kvertexnumber];
7998 TVector3 transvector[2];
7999 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
44285dfa 8000 /////////////////////////////////////////////////////////////
d7599219 8001 //Setting the vertices for TGeoArb8
44285dfa 8002 /////////////////////////////////////////////////////////////
b671cde1 8003 vertex[0] = *vertexpos[0];
8004 vertex[1] = *vertexpos[1];
8005 vertex[2] = vertex[1];
8006 vertex[3] = vertex[0];
8007 vertex[4] = *vertexpos[2];
8008 vertex[5] = *vertexpos[3];
8009 vertex[6] = vertex[5];
8010 vertex[7] = vertex[4];
8011
8012 // NB: order of points is clockwise
8013 if (isign < 0) {
8014 vertex[2] -= transvector[0];
8015 vertex[3] -= transvector[0];
8016 vertex[6] -= transvector[1];
8017 vertex[7] -= transvector[1];
8018 }
8019 else {
8020 vertex[0] += transvector[0];
8021 vertex[1] += transvector[0];
8022 vertex[4] += transvector[1];
8023 vertex[5] += transvector[1];
8024 }
8025
44285dfa 8026 /////////////////////////////////////////////////////////////
8027 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
b671cde1 8028 for(Int_t i = 0; i<kvertexnumber;i++) {
8029 arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
8030 }
8031
44285dfa 8032 return arbshape;
d7599219 8033}
bf210566 8034///////////////////////////////////////////////////////////////////////////////
8035TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8036 Double_t rmax, Int_t nedges, Double_t height){
8037 /////////////////////////////////////////////////////////////
8038 // Method generating Arc shape
8039 /////////////////////////////////////////////////////////////
8040 const Int_t kvertexnumber = 2*nedges+2;
8041 TGeoXtru* arcshape = new TGeoXtru(2);
8042 TVector3** vertexposition[2];
8043 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8044 Double_t angle = 0.;
8045 for(Int_t i=0; i<nedges+1; i++){
8046 angle = 90.+0.5*phi-i*(phi/nedges);
c2aad3ae 8047 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle),0);
8048 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle),0);
bf210566 8049 }
8050 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8051 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8052 for(Int_t i=0; i<kvertexnumber; i++){
8053 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8054 yvertexpoints[i] = vertexposition[0][i]->Y();
8055 }
8056 else if(i>=1&&i<nedges+2)
8057 {
8058 xvertexpoints[i] = vertexposition[1][i-1]->X();
8059 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8060 }
8061 else
8062 {
8063 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8064 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8065 }
8066 }
8067 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8068 arcshape->DefineSection(0,-0.5*height);
8069 arcshape->DefineSection(1,0.5*height);
44285dfa 8070 /////////////////////////////////////////////////////////////
bf210566 8071 // Deallocating memory
44285dfa 8072 /////////////////////////////////////////////////////////////
bf210566 8073 for(Int_t i=0; i<2; i++){
8074 for(Int_t j=0; j<nedges+1; j++)
8075 delete vertexposition[i][j];
8076 delete [] vertexposition[i];
8077 }
8078 delete [] xvertexpoints;
8079 delete [] yvertexpoints;
8080 /////////////////////////////////////////////////////////////
8081 return arcshape;
d7599219 8082}
8083////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8084TGeoShape* AliITSv11GeometrySSD::GetScrewShape(const Double_t* radius,const Int_t* edgesnumber,const Double_t* section) const {
9b0c60ab 8085 ///////////////////////////////////////////////////////////////////////
8086 // Method Generating the Screw Shape
8087 // radius[0]: outer radius
8088 // radius[1]: inner radius
8089 // edgesnumber[0]: outer number of edges
8090 // edgesnumber[1]: inner number of edges
8091 // section[0]: lower section position
8092 // section[1]: higher section position
8093 ///////////////////////////////////////////////////////////////////////
8094 Double_t outradius = radius[0];
8095 Double_t inradius = radius[1];
8096 Int_t outvertexnumber = edgesnumber[0];
8097 Int_t invertexnumber = edgesnumber[1];
851c0ce3 8098 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8099 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8100 for(Int_t i=0; i<outvertexnumber; i++){
9b0c60ab 8101 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8102 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8103 }
851c0ce3 8104 for(Int_t i=0; i<invertexnumber; i++){
8105 xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8106 yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
9b0c60ab 8107 }
851c0ce3 8108 TGeoXtru* screwshapeout = new TGeoXtru(2);
8109 screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8110 screwshapeout->DefineSection(0,section[0]);
8111 screwshapeout->DefineSection(1,section[1]);
8112 TGeoXtru* screwshapein = new TGeoXtru(2);
8113 screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8114 screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8115 screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8116 TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8117 TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8118
9b0c60ab 8119 delete [] xscrewvertex;
8120 delete [] yscrewvertex;
8121 return screwshape;
8122}
8123////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8124TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, const Double_t *section) const {
9b0c60ab 8125 ///////////////////////////////////////////////////////////////////////
8126 // Method Generating the Hole Shape
8127 // radius of the Hole
8128 // nedges: number of edges to approximate the circle
8129 ///////////////////////////////////////////////////////////////////////
851c0ce3 8130 Double_t* xholevertex = new Double_t[nedges];
8131 Double_t* yholevertex = new Double_t[nedges];
8132 Double_t z = 0.5*(section[0]+section[1]);
8133 Double_t dz = 0.5*(section[1]-section[0]);
8134 TGeoTranslation *tr = 0;
8135 if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8136 tr = new TGeoTranslation(0.,0.,z);
8137 tr->RegisterYourself();
8138 }
8139 TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8140 for(Int_t i=0; i<nedges; i++){
8141 xholevertex[i] = radius*CosD(i*360./nedges);
8142 yholevertex[i] = radius*SinD(i*360./nedges);
9b0c60ab 8143 }
851c0ce3 8144 TGeoXtru* holeshapeout = new TGeoXtru(2);
8145 holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8146 holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8147 holeshapeout->DefineSection(1,section[1]+0.01);
8148 TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8149 TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8150
9b0c60ab 8151 delete [] xholevertex;
8152 delete [] yholevertex;
8153 return holeshape;
8154}
8155////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8156TVector3* AliITSv11GeometrySSD::GetReflection(const TVector3* vector,const Double_t* param) const{
44285dfa 8157 /////////////////////////////////////////////////////////////
8158 // Given an axis specified by param, it gives the reflection of the point
8159 // respect to the axis
8160 /////////////////////////////////////////////////////////////
8161 TVector3* n = new TVector3(param[0],param[1],param[2]);
8162 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8163 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 8164 /////////////////////////////////////////////////////////////
8165 // Deallocating memory
8166 /////////////////////////////////////////////////////////////
8167 delete n;
8168 /////////////////////////////////////////////////////////////
44285dfa 8169 return reflectedvector;
d7599219 8170}
8171////////////////////////////////////////////////////////////////////////////////
f510fd70 8172TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(const TGeoHMatrix* ct,
d7599219 8173 Double_t dx,
8174 Double_t dy,
8175 Double_t dz) const{
44285dfa 8176 /////////////////////////////////////////////////////////////
d7599219 8177 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 8178 /////////////////////////////////////////////////////////////
bf210566 8179 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8180 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 8181 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 8182 hmatrix->SetTranslation(newvect);
8183 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8184 delete hmatrix;
8185 return matrix;
d7599219 8186}
8187////////////////////////////////////////////////////////////////////////////////
d7599219 8188TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 8189 /////////////////////////////////////////////////////////////
8190 // Method returning the Medium type
8191 /////////////////////////////////////////////////////////////
a3f8715e 8192 char ch[100];
045be90c 8193 snprintf(ch,100, "ITS_%s",mediumName);
d7599219 8194 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8195 if (! medium)
160835d5 8196 AliError(Form("medium %s not found !\n", mediumName));
d7599219 8197 return medium;
8198}
8199////////////////////////////////////////////////////////////////////////////////
d7599219 8200void AliITSv11GeometrySSD::CreateMaterials(){
8201///////////////////////////////////
8202// This part has to be modified
8203///////////////////////////////////
8204 ///////////////////////////////////
8205 // Silicon for Sensor
8206 ///////////////////////////////////
bf210566 8207 fSSDSensorMedium = GetMedium("SI$");
d7599219 8208 ///////////////////////////////////
8209 // Silicon Mixture for Sensor
8210 ///////////////////////////////////
44285dfa 8211 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8212 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 8213 ///////////////////////////////////
8214 // Stiffener Components Materials
8215 ///////////////////////////////////
bf210566 8216 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 8217 ///////////////////////////
8218 // Stiffener Connectors
8219 ///////////////////////////
bf210566 8220 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 8221 ////////////////////////////////
8222 // Stiffener 0603-1812 Capacitor
8223 ////////////////////////////////
bf210566 8224 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8225 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
78e34526 8226 fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$");
d7599219 8227 ///////////////////////////
8228 // Stiffener Hybrid Wire
8229 ///////////////////////////
bf210566 8230 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 8231 ///////////////////////////
8232 // Al for Cooling Block
8233 ///////////////////////////
bf210566 8234 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 8235 //////////////////////////////////////////////////////
8236 // Kapton and Al for Chip Cable Flex and Ladder Cables
8237 //////////////////////////////////////////////////////
bf210566 8238 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8239 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8240 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8241 fSSDAlTraceFlexMedium = GetMedium("AL$");
8242 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8243 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 8244 /////////////////////////////////////////////////////////////////
8245 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8246 //////////////////////////////////////////////////////////////////
44285dfa 8247 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 8248 /////////////////////////////////////////////////////////////////
8249 // G10 for Detector Leg, TubeHolder
8250 //////////////////////////////////////////////////////////////////
44285dfa 8251 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8252 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8253 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8254 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 8255 /////////////////////////////////////////////////////////////////
8256 // Water and Phynox for Cooling Tube
8257 //////////////////////////////////////////////////////////////////
bf210566 8258 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 8259 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 8260 /////////////////////////////////////////////////////////////////////
9b0c60ab 8261 // Material for Support Rings
8262 /////////////////////////////////////////////////////////////////////
8263 fSSDSupportRingAl = GetMedium("AL$");
47f8de53 8264 fSSDRohaCellCone = GetMedium("ROHACELL$");
9b0c60ab 8265 /////////////////////////////////////////////////////////////////////
bf210566 8266 fSSDAir = GetMedium("SDD AIR$");
47f8de53 8267 fSSDCopper = GetMedium("COPPER$");
78e34526 8268 fSSDSn = GetMedium("Sn$");
bf210566 8269 fCreateMaterials = kTRUE;
d7599219 8270}
8271/////////////////////////////////////////////////////////////////////
277f0a14 8272