]> 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
bug fix
[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/////////////////////////////////////////////////////////////////////////////////
02d4acf9 45const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5";
46const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "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};
497const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
498const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
499const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
500const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
501/////////////////////////////////////////////////////////////////////////////////
47f8de53 502// SSD Cone Parameters (lengths are in mm and angles in degrees)
503/////////////////////////////////////////////////////////////////////////////////
504const Double_t AliITSv11GeometrySSD::fgkSSDLowerPConeRadius = 296.5*fgkmm;
505const Double_t AliITSv11GeometrySSD::fgkSSDPConeAngle = 39.0;
fcfbdd23 506const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {168.0*fgkmm,153.0*fgkmm};
47f8de53 507const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleRadius = 317.5*fgkmm;
508const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleLength = 20.*fgkmm;
509const Double_t AliITSv11GeometrySSD::fgkSSDConeMiddleRadius = 350.*fgkmm;
510const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleLength = 30.*fgkmm;
511const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleWidth = 40.*fgkmm;
512const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpRadius = 400.*fgkmm;
fcfbdd23 513const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 459.*fgkmm;
47f8de53 514const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMiddleRadius = 472.5*fgkmm;
515const Double_t AliITSv11GeometrySSD::fgkSSDPConeDownRadius = 282.0*fgkmm;
516const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidAngle = 42.0;
517const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidBasis = 200.0*fgkmm;
518const Double_t AliITSv11GeometrySSD::fgkSSDPConeExternalRadius = 492.5*fgkmm;
519const Double_t AliITSv11GeometrySSD::fgkSSDPConeRadiusWidth = 16.75*fgkmm;
fcfbdd23 520const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 168.0*fgkmm;
47f8de53 521const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportLength = 1020.*fgkmm;
522const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm;
523const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm;
524const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportLength = 60.0*fgkmm;
525const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportWidth = 2.5*fgkSSDCentralSupportWidth;
526/////////////////////////////////////////////////////////////////////////////////
527// SSD Cables Parameters (lengths are in mm and angles in degrees)
528/////////////////////////////////////////////////////////////////////////////////
529const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
530const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
531const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
532const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
533const Double_t AliITSv11GeometrySSD::fgkSSDCableAngle = 22.5;
534const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm; // to be fixed in order to reproduce material budget
535const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
536const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
537const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
538const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
539const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = 451.3*fgkmm;
540const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = 451.3*fgkmm;
cd2243fb 541const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeight = 87.5*fgkmm;
47f8de53 542const Double_t AliITSv11GeometrySSD::fgkSSDCableMaterialBudgetHeight = 20.0*fgkmm;
543//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = fgkSSDPConeExternalRadius;
544//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = fgkSSDPConeExternalRadius;
545/////////////////////////////////////////////////////////////////////////////////
44285dfa 546ClassImp(AliITSv11GeometrySSD)
547/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 548AliITSv11GeometrySSD::AliITSv11GeometrySSD():
549 AliITSv11Geometry(),
44285dfa 550 fSSDChipMedium(),
551 fSSDChipGlueMedium(),
552 fSSDStiffenerMedium(),
553 fSSDStiffenerConnectorMedium(),
554 fSSDStiffener0603CapacitorMedium(),
555 fSSDStiffener1812CapacitorMedium(),
78e34526 556 fSSDStiffenerCapacitorCapMedium(),
44285dfa 557 fSSDStiffenerHybridWireMedium(),
558 fSSDKaptonFlexMedium(),
559 fSSDAlTraceFlexMedium(),
560 fSSDAlTraceLadderCableMedium(),
561 fSSDKaptonLadderCableMedium(),
562 fSSDKaptonChipCableMedium(),
563 fSSDAlTraceChipCableMedium(),
564 fSSDAlCoolBlockMedium(),
565 fSSDSensorMedium(),
566 fSSDSensorSupportMedium(),
567 fSSDCarbonFiberMedium(),
568 fSSDTubeHolderMedium(),
569 fSSDCoolingTubeWater(),
570 fSSDCoolingTubePhynox(),
9b0c60ab 571 fSSDSupportRingAl(),
44285dfa 572 fSSDMountingBlockMedium(),
47f8de53 573 fSSDRohaCellCone(),
bf210566 574 fSSDAir(),
47f8de53 575 fSSDCopper(),
78e34526 576 fSSDSn(),
bf210566 577 fCreateMaterials(kFALSE),
578 fTransformationMatrices(kFALSE),
579 fBasicObjects(kFALSE),
580 fcarbonfiberjunction(),
581 fcoolingtubesupport(),
582 fhybridmatrix(),
583 fssdcoolingblocksystem(),
584 fcoolingblocksystematrix(),
585 fssdstiffenerflex(),
586 fssdendflex(),
cd2243fb 587 fcoolingtube(0),
9b0c60ab 588 fendladdercoolingtubesupportmatrix(),
bf210566 589 fendladdermountingblock(),
9b0c60ab 590 fendladdermountingblockclip(),
bf210566 591 fSSDSensor5(),
592 fSSDSensor6(),
593 fSSDLayer5(),
594 fSSDLayer6(),
595 fMotherVol(),
9b0c60ab 596 fLay5LadderSupportRing(),
597 fLay6LadderSupportRing(),
e5bf64ae 598 fgkEndCapSupportSystem(),
47f8de53 599 fSSDCone(),
44285dfa 600 fColorCarbonFiber(4),
601 fColorRyton(5),
bf210566 602 fColorPhynox(14),
44285dfa 603 fColorSilicon(3),
bf210566 604 fColorAl(38),
78e34526 605 fColorNiSn(40),
44285dfa 606 fColorKapton(6),
607 fColorPolyhamide(5),
608 fColorStiffener(9),
bf210566 609 fColorEpoxy(30),
610 fColorWater(7),
611 fColorG10(41)
44285dfa 612{
613 ////////////////////////
614 // Standard constructor
615 ////////////////////////
045be90c 616
617 for (Int_t i=0; i < fgkcarbonfibersupportnumber; i++) {
618 fcarbonfibersupport[i] = 0;
619 fcarbonfibersupportmatrix[i] = 0;
620 }
621 for (Int_t i=0; i < fgkcarbonfiberjunctionumber; i++) {
622 fcarbonfiberjunctionmatrix[i] = 0;
623 }
624 for (Int_t i=0; i < fgkcarbonfiberlowersupportnumber; i++) {
625 fcarbonfiberlowersupport[i] = 0;
626 fcarbonfiberlowersupportrans[0] = 0;
627 }
628 for (Int_t i=0; i < fgkvolumekind; i++) {
629 fssdsensorsupport[i] = 0;
630 }
631 for (Int_t i=0; i < fgkssdsensorsupportnumber; i++) {
632 fssdsensorsupportmatrix[i] = 0;
633 }
634 for (Int_t i=0; i < fgkcoolingtubesupportnumber; i++) {
635 fcoolingtubesupportmatrix[i] = 0;
636 }
637 for (Int_t i=0; i < fgkhybridcompnumber; i++) {
638 fssdhybridcomponent[i] = 0;
639 }
640 for (Int_t i=0; i < fgkcoolingblocknumber; i++) {
641 fcoolingblockmatrix[i] = 0;
642 }
643 for (Int_t i=0; i < fgkflexnumber; i++) {
644 fstiffenerflexmatrix[i] = 0;
645 fendflexmatrix[i] = 0;
646 }
647 for (Int_t i=0; i < fgkendladdercoolingtubenumber; i++) {
648 fendladdercoolingtube[i] = 0;
649 for (Int_t j = 0; j < 2; j++)
650 fendladdercoolingtubematrix[i][j] = 0;
651 }
652 for (Int_t i=0; i < fgkendlabbercarbonfiberjunctionumber; i++) {
653 fendladdercarbonfiberjunction[i] = 0;
654 }
655 for (Int_t i=0; i < fgkendladdercabonfiberjunctionmatrixnumber; i++) {
656 fendladdercarbonfiberjunctionmatrix[i] = 0;
657 }
658 for (Int_t i=0; i < fgkendladdercarbonfibermatrixnumber; i++) {
659 fendladdercarbonfibermatrix[i] = 0;
660 }
661 for (Int_t i=0; i < fgkendladdermountingblocknumber; i++) {
662 fendladdermountingblockclipmatrix[i] = 0;
663 }
664 for (Int_t i = 0; i < fgkendladderlowersuppnumber+1; i++) {
665 fendladderlowersupptrans[i] = 0;
666 }
667 for (Int_t i = 0; i < fgkladdercablesnumber; i++) {
668 fladdercablematrix[i] = 0;
669 }
670 for (Int_t i = 0; i < fgkladdersegmentnumber; i++) {
671 fladdersegment[i] = 0;
672 }
673 for (Int_t i = 0; i < fgkladdernumber; i++) {
674 fladder[i] = 0;
675 fladdermatrix[i] = 0;
676 fssdsensormatrix[i] = 0;
677 flayermatrix[i] = 0;
678 }
679 for (Int_t i = 0; i < 2; i++) {
680 fLay5LadderSupport[i] = 0;
681 fLay6LadderSupport[i] = 0;
682 }
44285dfa 683}
684/////////////////////////////////////////////////////////////////////////////////
685AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
9acf2ecc 686 AliITSv11Geometry(s.GetDebug()),
44285dfa 687 fSSDChipMedium(s.fSSDChipMedium),
688 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
689 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
690 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
691 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
692 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
78e34526 693 fSSDStiffenerCapacitorCapMedium(s.fSSDStiffenerCapacitorCapMedium),
44285dfa 694 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
695 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
696 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
697 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
698 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
699 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
700 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
701 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
702 fSSDSensorMedium(s.fSSDSensorMedium),
703 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
704 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
705 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
706 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
707 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
9b0c60ab 708 fSSDSupportRingAl(s.fSSDSupportRingAl),
44285dfa 709 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
47f8de53 710 fSSDRohaCellCone(s.fSSDRohaCellCone),
bf210566 711 fSSDAir(s.fSSDAir),
78e34526 712 fSSDCopper(s.fSSDCopper),
713 fSSDSn(s.fSSDSn),
bf210566 714 fCreateMaterials(s.fCreateMaterials),
715 fTransformationMatrices(s.fTransformationMatrices),
716 fBasicObjects(s.fBasicObjects),
717 fcarbonfiberjunction(s.fcarbonfiberjunction),
718 fcoolingtubesupport(s.fcoolingtubesupport),
719 fhybridmatrix(s.fhybridmatrix),
720 fssdcoolingblocksystem(s.fssdcoolingblocksystem),
721 fcoolingblocksystematrix(s.fcoolingblocksystematrix),
722 fssdstiffenerflex(s.fssdstiffenerflex),
723 fssdendflex(s.fssdendflex),
cd2243fb 724 fcoolingtube(s.fcoolingtube),
9b0c60ab 725 fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
bf210566 726 fendladdermountingblock(s.fendladdermountingblock),
9b0c60ab 727 fendladdermountingblockclip(s.fendladdermountingblockclip),
bf210566 728 fSSDSensor5(s.fSSDSensor5),
729 fSSDSensor6(s.fSSDSensor6),
730 fSSDLayer5(s.fSSDLayer5),
731 fSSDLayer6(s.fSSDLayer6),
44285dfa 732 fMotherVol(s.fMotherVol),
9b0c60ab 733 fLay5LadderSupportRing(s.fLay5LadderSupportRing),
734 fLay6LadderSupportRing(s.fLay6LadderSupportRing),
e5bf64ae 735 fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
47f8de53 736 fSSDCone(s.fSSDCone),
44285dfa 737 fColorCarbonFiber(s.fColorCarbonFiber),
738 fColorRyton(s.fColorRyton),
739 fColorPhynox(s.fColorPhynox),
740 fColorSilicon(s.fColorSilicon),
741 fColorAl(s.fColorAl),
78e34526 742 fColorNiSn(s.fColorNiSn),
44285dfa 743 fColorKapton(s.fColorKapton),
744 fColorPolyhamide(s.fColorPolyhamide),
745 fColorStiffener(s.fColorStiffener),
bf210566 746 fColorEpoxy(s.fColorEpoxy),
747 fColorWater(s.fColorWater),
748 fColorG10(s.fColorG10)
44285dfa 749{
750 ////////////////////////
751 // Copy Constructor
752 ////////////////////////
d7599219 753}
754/////////////////////////////////////////////////////////////////////////////////
44285dfa 755AliITSv11GeometrySSD& AliITSv11GeometrySSD::
756operator=(const AliITSv11GeometrySSD &s){
757 ////////////////////////
758 // Assignment operator
759 ////////////////////////
760 this->~AliITSv11GeometrySSD();
761 new(this) AliITSv11GeometrySSD(s);
762 return *this;
763/*
764 if(&s == this) return *this;
765 fMotherVol = s.fMotherVol;
766 return *this;
767 */
768}
bf210566 769///////////////////////////////////////////////////////////////////////////////
770void AliITSv11GeometrySSD::CreateTransformationMatrices(){
771 ///////////////////////////////////////////////////////////////////////
772 // Method generating the trasformation matrix for the whole SSD Geometry
773 ///////////////////////////////////////////////////////////////////////
774 // Setting some variables for Carbon Fiber Supportmatrix creation
775 //////////////////////////////////////////////////////////////////////
776 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
777 * CosD(fgkCarbonFiberJunctionAngle[0]);
778 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
779 + fgkCarbonFiberSupportTopEdgeDist[0]
780 + fgkCarbonFiberSupportWidth);
781 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
782 * TanD(fgkCarbonFiberJunctionAngle[0]);
783 TGeoRotation* carbonfiberot[3];
784 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
785 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
786 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
787 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
788 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
789 * CosD(fgkCarbonFiberTriangleAngle),0.,
790 - fgkCarbonFiberTriangleLength
791 * SinD(fgkCarbonFiberTriangleAngle)};
792 ///////////////////////////////////////////
793 //Setting Local Translations and Rotations:
794 ///////////////////////////////////////////
795 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
796 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
797 0.5*carbonfibersupportheight,NULL);
798 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
799 2.*symmetryplaneposition+transvector[1],
800 transvector[2], carbonfiberot[2]);
801 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
802 /////////////////////////////////////////////////////////////
803 // Carbon Fiber Support Transformations
804 /////////////////////////////////////////////////////////////
805 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
806 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
807 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
808 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
809 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
810 }
811 /////////////////////////////////////////////////////////////
812 // Carbon Fiber Junction Transformation
813 /////////////////////////////////////////////////////////////
814 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
815 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
816 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
817 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
818 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
819 localcarbonfiberjunctionmatrix[i] =
820 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
821 localcarbonfiberjunctionrot[i] =
822 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
823 localcarbonfiberjunctiontrans[i] =
824 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 825 }
bf210566 826 ///////////////////////
827 // Setting Translations
828 ///////////////////////
829 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
830 localcarbonfiberjunctiontrans[1][0] =
831 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
832 localcarbonfiberjunctiontrans[2][0] =
833 new TGeoTranslation(fgkCarbonFiberTriangleLength
834 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
835 fgkCarbonFiberTriangleLength
836 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
837 localcarbonfiberjunctiontrans[0][1] =
838 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
839 localcarbonfiberjunctiontrans[1][1] =
840 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
841 localcarbonfiberjunctiontrans[2][1] =
842 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
843 ////////////////////
844 // Setting Rotations
845 ////////////////////
846 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
847 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
848 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
849 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
850 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
851 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
852 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
853 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
854 ////////////////////////////////////////
855 // Setting Carbon Fiber Junction matrix
856 ////////////////////////////////////////
857 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
858 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
859 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
860 localcarbonfiberjunctionmatrix[i][j] =
861 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
862 *localcarbonfiberjunctionrot[i][j]);
863 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
864 }
d7599219 865 }
bf210566 866 /////////////////////////////////////////////////////////////
867 // Carbon Fiber Lower Support Transformations
868 /////////////////////////////////////////////////////////////
869 TGeoTranslation* localcarbonfiberlowersupportrans[2];
870 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
871 fgkCarbonFiberLowerSupportVolumePosition[1]
872 + fgkCarbonFiberLowerSupportVolumePosition[0],
873 0.0);
874 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
875 fgkCarbonFiberJunctionWidth
876 - fgkCarbonFiberLowerSupportWidth
877 - fgkCarbonFiberLowerSupportVolumePosition[0]
878 - fgkCarbonFiberLowerSupportVolumePosition[1],
879 - 0.5*fgkCarbonFiberLowerSupportHeight);
880 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
881 fcarbonfiberlowersupportrans[0] =
882 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
883 fcarbonfiberlowersupportrans[1] =
884 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
885 /////////////////////////////////////////////////////////////
886 // SSD Sensor Support Transformations
887 /////////////////////////////////////////////////////////////
888 const Int_t kssdsensorsupportmatrixnumber = 3;
889 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
890 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
891 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
892 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
893 localssdsensorsupportmatrix[i] =
894 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
895 localssdsensorsupportrot[i] =
896 new TGeoRotation*[kssdsensorsupportmatrixnumber];
897 localssdsensorsupportrans[i] =
898 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 899 }
bf210566 900 ///////////////////////
901 // Setting Translations
902 ///////////////////////
903 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
904 0.5*fgkSSDSensorSideSupportWidth,
905 0.0);
906 localssdsensorsupportrans[1][0] =
907 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
908 localssdsensorsupportrans[2][0] =
909 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
910 localssdsensorsupportrans[0][1] =
911 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
912 0.5*fgkSSDSensorSideSupportThickness[0],
913 0.0);
914 localssdsensorsupportrans[1][1] =
915 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
916 - 0.5*fgkSSDSensorSideSupportThickness[0]
917 - fgkSSDModuleSensorSupportDistance,
918 0.0);
919 localssdsensorsupportrans[2][1] =
920 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
921 - fgkSSDSensorCenterSupportPosition,
922 0.5*fgkSSDSensorCenterSupportWidth
923 - 0.5*fgkSSDModuleSensorSupportDistance,
924 fgkSSDSensorCenterSupportThickness[0]);
925 localssdsensorsupportrans[0][2] =
926 new TGeoTranslation(fgkCarbonFiberTriangleLength
927 + fgkCarbonFiberJunctionToSensorSupport,
928 fgkCarbonFiberJunctionWidth
929 - 0.5*(fgkCarbonFiberLowerSupportWidth
930 + fgkSSDSensorCenterSupportLength
931 - fgkSSDSensorCenterSupportThickness[0])
932 - fgkSSDSensorCenterSupportPosition,
933 0.0);
934 localssdsensorsupportrans[1][2] =
935 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
936 localssdsensorsupportrans[2][2] =
937 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
938 ////////////////////
939 // Setting Rotations
940 ////////////////////
941 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
942 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
943 localssdsensorsupportrot[i][j] = new TGeoRotation();
944 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
945 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
946 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 947 }
bf210566 948 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
949 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
950 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
951 ////////////////////////////////////////
952 // SSD Sensor Support matrix
953 ////////////////////////////////////////
954 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
955 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
956 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
957 localssdsensorsupportmatrix[i][j] =
958 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
959 *localssdsensorsupportrot[i][j]);
960 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
961 }
d7599219 962 }
44285dfa 963 /////////////////////////////////////////////////////////////
bf210566 964 // SSD Cooling Tube Support Transformations
44285dfa 965 /////////////////////////////////////////////////////////////
bf210566 966 const Int_t kcoolingtubesupportmatrixnumber = 2;
967 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
968 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
969 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 970 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 971 /fgkCoolingTubeSupportRmax);
bf210566 972 localcoolingtubesupportrans[0] =
973 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 974 + 2.*(fgkCoolingTubeSupportLength
44285dfa 975 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 976 + fgkCarbonFiberTriangleLength
bf210566 977 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
978 localcoolingtubesupportrans[1] =
979 new TGeoTranslation(fgkCarbonFiberJunctionLength
980 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
981 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
982 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
983 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
984 - 0.5*(fgkCarbonFiberLowerSupportWidth
985 + fgkSSDSensorCenterSupportLength
986 - fgkSSDSensorCenterSupportThickness[0])
987 + 0.5*fgkSSDSensorLength,
988 - 0.5*fgkCoolingTubeSupportHeight);
989 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
990 localcoolingtubesupportrot[i] = new TGeoRotation();
991 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
992 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
993 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
994 localcoolingtubesupportmatrix[i] =
995 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
996 *localcoolingtubesupportrot[i]);
997 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
998 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
999 (*localcoolingtubesupportmatrix[0]));
1000 /////////////////////////////////////////////////////////////
9b0c60ab 1001 // End Ladder SSD Cooling Tube Support Transformations
1002 /////////////////////////////////////////////////////////////
1003 TGeoTranslation** localendladdercooltubetrans[2];
1004 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
1005 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
1006 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
1007 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
1008 - (fgkCoolingTubeSupportLength
1009 - fgkCoolingTubeSupportRmax),
1010 fgkEndLadderMountingBlockPosition[0]
1011 - fgkendladdercoolingsupportdistance[0]
1012 + 0.5*fgkCoolingTubeSupportWidth,
1013 - 0.5*fgkCoolingTubeSupportHeight);
1014 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
1015 - (fgkCoolingTubeSupportLength
1016 - fgkCoolingTubeSupportRmax),
1017 fgkEndLadderMountingBlockPosition[0]
1018 + fgkendladdercoolingsupportdistance[1]
1019 + 0.5*fgkCoolingTubeSupportWidth,
1020 - 0.5*fgkCoolingTubeSupportHeight);
1021 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
1022 - fgkCoolingTubeSupportRmax)
1023 + fgkCarbonFiberTriangleLength
1024 - 2.0*fgkCarbonFiberJunctionLength,
1025 0.0,
1026 0.0);
1027 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
1028 fgkendladdercoolingsupportdistance[0]
1029 + fgkendladdercoolingsupportdistance[1],
1030 0.0);
1031 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
1032 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
1033 + fgkCarbonFiberJunctionLength
1034 - fgkCoolingTubeSupportLength,
1035 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1036 - 0.5*fgkCoolingTubeSupportWidth
1037 -fgkendladdercoolingsupportdistance[2],
1038 - 0.5*fgkCoolingTubeSupportHeight);
1039 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
1040 + fgkCoolingTubeSupportLength
1041 - fgkCoolingTubeSupportRmax
1042 - fgkCarbonFiberJunctionLength,
1043 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1044 - 0.5*fgkCoolingTubeSupportWidth
1045 - fgkendladdercoolingsupportdistance[2],
1046 - 0.5*fgkCoolingTubeSupportHeight);
1047 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
1048 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
1049 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
1050 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
1051 (*localcoolingtubesupportrot[1]));
1052 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
1053 (*localcoolingtubesupportrot[1]));
1054 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
1055 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
1056 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
1057 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
1058 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
1059
1060 fendladdercoolingtubesupportmatrix[1][0] =
1061 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
1062 *(*localcoolingtubesupportrot[1]));
1063 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
1064 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
1065 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
1066 /////////////////////////////////////////////////////////////
bf210566 1067 // SSD Cooling Tube Transformations
1068 /////////////////////////////////////////////////////////////
1069 TGeoRotation* localcoolingtuberot = new TGeoRotation();
1070 localcoolingtuberot->SetAngles(0.,90.,0.);
cd2243fb 1071 TGeoTranslation* localcoolingtubetrans[2];
1072 TVector3* localcoolingtubevect[2];
1073
1074 localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
bf210566 1075 -fgkCarbonFiberTriangleLength),
cd2243fb 1076 fgkCarbonFiberJunctionWidth // Y-coord is local Z, from sensor translation
1077 - fgkCarbonFiberLowerSupportWidth
1078 - fgkLowerSupportToSensorZ ,
bf210566 1079 - 0.5*fgkCoolingTubeSupportHeight);
cd2243fb 1080 localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
1081 localcoolingtubevect[0]->Y(),
1082 localcoolingtubevect[0]->Z());
78e34526 1083 for(Int_t j=0; j<2; j++){
1084 localcoolingtubetrans[j] =
1085 new TGeoTranslation(localcoolingtubevect[j]->X(),
1086 localcoolingtubevect[j]->Y(),
1087 localcoolingtubevect[j]->Z());
1088 fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j])
1089 *(*localcoolingtuberot));
1090 }
bf210566 1091 /////////////////////////////////////////////////////////////
9b0c60ab 1092 // SSD End Ladder Cooling Tube Transformations
1093 /////////////////////////////////////////////////////////////
1094 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1095 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1096 TGeoTranslation** localendlladdercoolingtubetrans[2];
cd2243fb 1097 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
1098 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
9b0c60ab 1099 for(Int_t i=0; i<2; i++)
cd2243fb 1100 for(Int_t j=0; j<2; j++)
9b0c60ab 1101 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
cd2243fb 1102
1103 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
9b0c60ab 1104 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1105 - fgkCoolingTubeSupportRmax)
1106 + fgkCarbonFiberJunctionLength,
cd2243fb 1107 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
9b0c60ab 1108 - 0.5*fgkCoolingTubeSupportHeight);
1109 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1110 - fgkCoolingTubeSupportRmax)
1111 - fgkCarbonFiberJunctionLength
1112 + fgkCarbonFiberTriangleLength,
cd2243fb 1113 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
9b0c60ab 1114 - 0.5*fgkCoolingTubeSupportHeight);
cd2243fb 1115
9b0c60ab 1116 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
cd2243fb 1117 - fgkCoolingTubeSupportRmax)
1118 + fgkCarbonFiberJunctionLength,
1119 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
9b0c60ab 1120 - 0.5*fgkCoolingTubeSupportHeight);
1121 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1122 - fgkCoolingTubeSupportRmax)
1123 - fgkCarbonFiberJunctionLength
1124 + fgkCarbonFiberTriangleLength,
cd2243fb 1125 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
9b0c60ab 1126 - 0.5*fgkCoolingTubeSupportHeight);
9b0c60ab 1127 for(Int_t i=0; i<2; i++)
cd2243fb 1128 for(Int_t j=0; j<2; j++){
9b0c60ab 1129 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1130 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1131 }
1132 /////////////////////////////////////////////////////////////
bf210566 1133 // SSD Hybrid Components Transformations
1134 /////////////////////////////////////////////////////////////
1135 const Int_t khybridmatrixnumber = 3;
1136 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1137 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1138 0.5*fgkSSDStiffenerWidth,
1139 0.5*fgkSSDStiffenerHeight);
1140 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1141 fgkSSDModuleStiffenerPosition[1],0.0);
1142
1143 localhybridtrans[2] = new TGeoTranslation(
1144 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1145 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1146 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1147 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1148 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1149 - fgkSSDSensorCenterSupportThickness[0]),
1150 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
ca86fdb4 1151 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
0fb26117 1152 - fgkSSDModuleVerticalDisalignment));
bf210566 1153 fhybridmatrix = new TGeoHMatrix();
1154 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1155 /////////////////////////////////////////////////////////////
1156 // SSD Cooling Block Transformations
1157 /////////////////////////////////////////////////////////////
78e34526 1158 TGeoTranslation localcoolingblocktrans (fcoolingtubematrix[0]->GetTranslation()[0]
1159 - 0.5*fgkSSDCoolingBlockLength,
1160 fhybridmatrix->GetTranslation()[1]-0.5*fgkSSDStiffenerWidth,
1161 fhybridmatrix->GetTranslation()[2]+0.5*fgkSSDStiffenerHeight+
1162 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1163 fcoolingblocksystematrix = new TGeoHMatrix(localcoolingblocktrans);
bf210566 1164 /////////////////////////////////////////////////////////////
1165 // SSD Stiffener Flex Transformations
1166 /////////////////////////////////////////////////////////////
1167 const Int_t klocalflexmatrixnumber = 4;
1168 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1169 for(Int_t i=0; i<fgkflexnumber; i++)
1170 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1171 for(Int_t i=0; i<fgkflexnumber; i++)
1172 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1173 localflexmatrix[i][j] = new TGeoCombiTrans();
1174 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1175 - 2.*fgkSSDModuleStiffenerPosition[1]
1176 - fgkSSDStiffenerWidth;
1177 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1178 +0.5*fgkSSDStiffenerLength,
1179 0.5*fgkSSDStiffenerWidth,
1180 -0.5*fgkSSDStiffenerHeight
1181 -0.5*fgkSSDFlexHeight[0]);
1182 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1183 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1184 -0.5*fgkSSDStiffenerWidth,
1185 -0.5*fgkSSDStiffenerHeight
1186 -0.5*fgkSSDFlexHeight[0]);
1187 TGeoRotation* localflexrot = new TGeoRotation();
1188 localflexrot->SetAngles(180.,0.,0.);
1189 localflexmatrix[1][0]->SetRotation(localflexrot);
1190 for(Int_t i=0; i<fgkflexnumber; i++)
1191 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1192 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1193 for(Int_t i=0; i<fgkflexnumber; i++){
1194 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1195 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1196 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1197 }
bf210566 1198 /////////////////////////////////////////////////////////////
1199 // SSD End Flex Transformations
1200 /////////////////////////////////////////////////////////////
1201 TGeoRotation* localendflexrot = new TGeoRotation();
1202 localendflexrot->SetAngles(0.0,90.0,0.0);
1203 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1204 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1205 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1206 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1207 * TMath::DegToRad()*ssdflexradiusmax
1208 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 1209 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1210 - 0.1*fgkSSDFlexFullLength;
bf210566 1211 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1212 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1213 + fgkSSDFlexLength[2];
1214 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1215 0.5*fgkSSDFlexWidth[0],
1216 2.*fgkSSDStiffenerHeight
1217 + 0.5*fgkSSDFlexHeight[0]);
1218 localendflexmatrix->SetRotation(localendflexrot);
1219 for(Int_t i=0; i<fgkflexnumber; i++)
1220 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1221 /////////////////////////////////////////////////////////////
1222 // End Ladder Carbon Fiber Junction
1223 /////////////////////////////////////////////////////////////
1224 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1225 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1226 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1227 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1228 localendladdercarbonfiberjunctionmatrix[i]
1229 = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1230 localendladdercarbonfiberjunctionrot[i]
1231 = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1232 localendladdercarbonfiberjunctiontrans[i]
1233 = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1234 fendladdercarbonfiberjunctionmatrix[i]
1235 = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
d7599219 1236 }
bf210566 1237 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1238 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1239 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1240 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1241 }
1242 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1243 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1244 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1245 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1246 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1247 0.0,0.0);
1248 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1249 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1250 * SinD(fgkCarbonFiberTriangleAngle),
1251 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1252 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1253 }
1254 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1255 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1256 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1257 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1258 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1259 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1260 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1261 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1262 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1263 localendladdercarbonfiberjunctionglobalmatrix[i] =
1264 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1265 *localendladdercarbonfiberjunctionglobalrot[i]);
1266 }
1267 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1268 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1269 localendladdercarbonfiberjunctionmatrix[i][j] =
1270 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1271 *localendladdercarbonfiberjunctionrot[i][j]);
1272 fendladdercarbonfiberjunctionmatrix[i][j] =
1273 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1274 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1275 }
1276 /////////////////////////////////////////////////////////////
1277 // End Ladder Carbon Fiber Support
1278 /////////////////////////////////////////////////////////////
1279 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1280 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1281 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1282 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1283 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1284 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1285 }
1286 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1287 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1288 fendladdercarbonfibermatrix[i][j] =
1289 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1290 *(*fcarbonfibersupportmatrix[j]));
1291 /////////////////////////////////////////////////////////////
1292 // End Ladder SSD Mounting Block
1293 /////////////////////////////////////////////////////////////
1294 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1295 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1296 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1297 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1298 + fgkSSDMountingBlockLength[1])
1299 + 0.5*fgkCarbonFiberTriangleLength,
1300 fgkEndLadderMountingBlockPosition[i],
1301 - fgkSSDMountingBlockHeight[1]
1302 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1303 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1304 endladdermountingblockrot->SetAngles(0.,90.,0.);
1305 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1306 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1307 /////////////////////////////////////////////////////////////
1308 // End Ladder SSD Mounting Block Clip Matrix
1309 /////////////////////////////////////////////////////////////
1310 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1311 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1312
1313 TGeoRotation* localendladdercliprot = new TGeoRotation();
1314 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1315 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1316 - fgkSSDMountingBlockLength[1])
1317 + fgkSSDMountingBlockLength[0],0.,0.);
1318 localendladdercliprot->SetAngles(90.,180.,-90.);
1319 TGeoCombiTrans* localendladderclipcombitrans =
1320 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1321 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1322 for(Int_t j=0; j<2; j++){
1323 fendladdermountingblockclipmatrix[i][j] =
1324 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1325 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1326 }
bf210566 1327 /////////////////////////////////////////////////////////////
1328 // End Ladder Carbon Fiber Lower Support
1329 /////////////////////////////////////////////////////////////
1330 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1331 fendladderlowersupptrans[i] =
1332 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1333 + 0.5*fgkSSDMountingBlockWidth),
1334 - 0.5*fgkCarbonFiberLowerSupportHeight);
1335 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1336 fgkCarbonFiberLowerSupportVolumePosition[1]
1337 + fgkCarbonFiberLowerSupportVolumePosition[0],
1338 0.0);
1339 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1340 /////////////////////////////////////////////////////////////
1341 // Matrix for positioning Ladder into mother volume
1342 /////////////////////////////////////////////////////////////
1343 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1344 for(Int_t i=0; i<fgkladdernumber; i++)
1345 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1346 TGeoRotation* localladdermotherrot = new TGeoRotation();
1347 localladdermotherrot->SetAngles(0.,90.,0.);
1348 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1349 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1350 for(Int_t i=0; i<fgkladdernumber; i++){
1351 localladdermothertrans[i] = new TGeoTranslation(0.,
1352 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1353 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1354 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1355 * fgkCarbonFiberJunctionWidth,0.);
1356 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1357 *localladdermotherrot);
1358 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1359 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1360 }
44285dfa 1361 /////////////////////////////////////////////////////////////
bf210566 1362 // Ladder Cables Matrices
44285dfa 1363 /////////////////////////////////////////////////////////////
44285dfa 1364 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1365 + fgkSSDFlexHeight[1];
44285dfa 1366 Double_t ssdladdercabletransx[3];
1367 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1368 * SinD(2.*fgkSSDFlexAngle)
1369 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1370 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1371 - ssdladdercabletransx[0]
bf210566 1372 / SinD(2.*fgkSSDFlexAngle))
1373 * CosD(fgkSSDFlexAngle);
44285dfa 1374 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1375 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1376 - fgkSSDFlexLength[2]-TMath::Pi()
1377 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1378 - fgkSSDLadderCableWidth)
bf210566 1379 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1380 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1381 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1382 ssdladdercabletransx[1]
bf210566 1383 * TanD(fgkSSDFlexAngle),
44285dfa 1384 ssdladdercabletransx[2]
bf210566 1385 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1386 TGeoRotation* localladdercablerot[3];
bf210566 1387 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1388 localladdercablerot[0]->SetAngles(90.,0.,0.);
1389 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1390 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1391 * (*localladdercablerot[0]));
cd2243fb 1392 //TGeoRotation* localladdercablerot = new TGeoRotation();
1393 //localladdercablerot->SetAngles(90.,0.,0.);
44285dfa 1394 ////////////////////////////////////////////
1395 // LocalLadderCableCombiTransMatrix
1396 ////////////////////////////////////////////
1397 const Int_t klocalladdersidecablesnumber = 2;
1398 const Int_t klocalladdercombitransnumber = 5;
1399 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1400 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1401 localladdercablecombitransmatrix[i] =
1402 new TGeoCombiTrans*[klocalladdercombitransnumber];
1403 ///////////////////////////////////////////
1404 // Left Side Ladder Cables Transformations
1405 ///////////////////////////////////////////
1406 localladdercablecombitransmatrix[0][0] =
d7599219 1407 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1408 0.,0.,NULL);
bf210566 1409 localladdercablecombitransmatrix[0][1] =
1410 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1411 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1412 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1413 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1414 - 0.5*(fgkCarbonFiberLowerSupportWidth
1415 + fgkSSDSensorCenterSupportLength
1416 - fgkSSDSensorCenterSupportThickness[0]),
1417 - (fgkSSDModuleCoolingBlockToSensor
1418 + 0.5*fgkCoolingTubeSupportHeight
1419 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1420 - fgkSSDChipHeight),NULL);
44285dfa 1421 localladdercablecombitransmatrix[0][2] =
d7599219 1422 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1423 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1424 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1425 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1426 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1427 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1428 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1429 new TGeoRotation("",180.,0.,0.));
44285dfa 1430 localladdercablecombitransmatrix[0][4] =
1431 new TGeoCombiTrans(-ssdladdercabletransx[0]
1432 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1433 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1434 0.,
1435 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1436 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1437 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1438 + ssdladdercabletransz[2],localladdercablerot[2]);
1439 ///////////////////////////////////////////
1440 // Rigth Side Ladder Cables Transformations
1441 ///////////////////////////////////////////
bf210566 1442 TGeoCombiTrans* localladdercablessdmodulematrix =
1443 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1444 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1445 fgkSSDStiffenerWidth,
1446 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1447 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1448 localladdercablecombitransmatrix[1][i] =
bf210566 1449 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1450 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1451 ///////////////////////////////////////////
bf210566 1452 // Setting LadderCableHMatrix
44285dfa 1453 ///////////////////////////////////////////
bf210566 1454 Int_t beamaxistrans[2][3];
1455 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1456 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1457 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1458 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1459 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1460 beamaxistrans[1][2] = beamaxistrans[1][0];
1461 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1462 TGeoRotation* laddercablerot = new TGeoRotation();
1463 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1464 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1465 Double_t* laddercabletransvector;
1466 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1467 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1468 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1469 }
1470 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1471 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1472 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1473 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1474 localladdercablehmatrix[i][j]->MultiplyLeft(
1475 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1476 }
1477 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1478 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1479 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1480 laddercabletransvector[1]
bf210566 1481 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1482 * fgkCarbonFiberJunctionWidth,
bf210566 1483 laddercabletransvector[2]);
1484 laddercablecombitrans->SetRotation(*laddercablerot);
1485 laddercablecombitrans->SetTranslation(*laddercabletrans);
1486 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1487 }
1488 fladdercablematrix[i][2] =
1489 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1490 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1491 fladdercablematrix[i][3] =
1492 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1493 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1494 }
1495 for(Int_t i=0; i<fgkladdercablesnumber; i++)
78e34526 1496 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1497 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1498
bf210566 1499 ///////////////////////////////////////////
1500 // Setting Ladder HMatrix
1501 ///////////////////////////////////////////
1502 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1503 fgkSSDLay6SensorsNumber};
1504 for(Int_t i=0; i<fgkladdernumber; i++){
1505 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1506 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1507 fladdermatrix[i][j] = new TGeoHMatrix();
1508 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1509 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1510 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1511 }
1512 }
1513 ///////////////////////////////////////////
1514 // Setting SSD Sensor Matrix
1515 ///////////////////////////////////////////
1516 TGeoCombiTrans* localssdsensorcombitrans[2];
1517 TGeoRotation* localssdsensorrot = new TGeoRotation();
1518 localssdsensorrot->SetAngles(0.,90.,0.);
1519 TGeoTranslation* localssdsensortrans[2];
1520 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1521 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1522 fgkCarbonFiberJunctionWidth
1523 - fgkCarbonFiberLowerSupportWidth
1524 - fgkLowerSupportToSensorZ,
bf210566 1525 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1526 - fgkSSDModuleCoolingBlockToSensor
e21cdd03 1527 + (fgkSSDSensorSideSupportHeight[1]
0fb26117 1528 - fgkSSDSensorSideSupportHeight[0]));
bf210566 1529 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1530 fgkCarbonFiberJunctionWidth
1531 - fgkCarbonFiberLowerSupportWidth
1532 - fgkLowerSupportToSensorZ,
bf210566 1533 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1534 -fgkSSDModuleCoolingBlockToSensor);
cd2243fb 1535
bf210566 1536 for(Int_t i=0; i<2; i++)
1537 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1538 *localssdsensorrot);
1539 for(Int_t i=0; i<fgkladdernumber; i++){
1540 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1541 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1542 switch(i){
1543 case 0: //Ladder of Layer5
1544 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1545 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1546 *localssdsensorcombitrans[1])));
1547 break;
1548 case 1: //Ladder of Layer6
1549 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1550 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1551 *localssdsensorcombitrans[0])));
1552 break;
1553 }
1554 }
1555 }
1556 //////////////////////////
1557 // Setting SSD End Ladder
1558 //////////////////////////
1559 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1560 for(Int_t i=0; i<2; i++){
1561 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1562 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1563 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1564 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1565 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1566 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1567 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1568 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1569 }
1570 /////////////////////////////////////////////////////
1571 // Setting the CombiTransformation to pass ITS center
1572 /////////////////////////////////////////////////////
1573 Double_t itscentertransz[fgklayernumber];
1574 itscentertransz[0] = fgkSSDLay5LadderLength
1575 - fgkLay5CenterITSPosition;
1576 itscentertransz[1] = fgkSSDLay6LadderLength
1577 - fgkLay6CenterITSPosition;
1578 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1579 + 0.5*fgkCoolingTubeSupportHeight;
1580 TGeoRotation* itscenterrot[3];
1581 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1582 itscenterrot[0]->SetAngles(90.,180.,-90.);
1583 itscenterrot[1]->SetAngles(0.,90.,0.);
1584 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1585 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1586 for(Int_t i=0; i<fgklayernumber; i++)
1587 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1588 itssensortransy,
1589 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1590 - itscentertransz[i],itscenterrot[2]);
1591 TGeoRotation** locallayerrot[fgklayernumber];
1592 TGeoTranslation** locallayertrans[fgklayernumber];
1593 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1594 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1595 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1596 - fgkLay5CenterITSPosition);
1597 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1598 - fgkLay6CenterITSPosition);
1599 const Int_t kssdlayladdernumber[fgklayernumber] =
1600 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1601 for(Int_t i=0; i<fgklayernumber; i++){
1602 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1603 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1604 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1605 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1606 }
1607 Double_t layerladderangleposition[fgklayernumber] =
1608 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1609 Double_t layerradius = 0.;
1610 for(Int_t i=0; i<fgklayernumber; i++){
1611 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1612 switch(i){
1613 case 0: //Ladder of Layer5
1614 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1615 break;
1616 case 1: //Ladder of Layer6
1617 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1618 break;
1619 }
1620 locallayerrot[i][j] = new TGeoRotation();
1621 locallayertrans[i][j] = new TGeoTranslation();
1622 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1623 locallayertrans[i][j]->SetTranslation(layerradius
1624 * CosD(90.0+j*layerladderangleposition[i]),
1625 layerradius
1626 * SinD(90.0+j*layerladderangleposition[i]),0.);
1627 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1628 *locallayerrot[i][j]);
1629 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1630 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1631 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1632 }
1633 }
44285dfa 1634 /////////////////////////////////////////////////////////////
bf210566 1635 // Deallocating memory
44285dfa 1636 /////////////////////////////////////////////////////////////
bf210566 1637 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1638 delete carbonfiberot[i];
1639 delete localcarbonfibersupportmatrix[i];
1640 }
1641 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1642 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1643 delete localcarbonfiberjunctionmatrix[i][j];
1644 delete localcarbonfiberjunctionrot[i][j];
1645 delete localcarbonfiberjunctiontrans[i][j];
1646 }
1647 delete [] localcarbonfiberjunctionmatrix[i];
1648 delete [] localcarbonfiberjunctionrot[i];
1649 delete [] localcarbonfiberjunctiontrans[i];
1650 }
1651 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1652 delete localcarbonfiberlowersupportrans[i];
1653 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1654 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1655 delete localssdsensorsupportmatrix[i][j];
1656 delete localssdsensorsupportrot[i][j];
1657 delete localssdsensorsupportrans[i][j];
1658 }
1659 delete [] localssdsensorsupportmatrix[i];
1660 delete [] localssdsensorsupportrot[i];
1661 delete [] localssdsensorsupportrans[i];
1662 }
1663 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1664 delete localcoolingtubesupportmatrix[i];
1665 delete localcoolingtubesupportrot[i];
1666 delete localcoolingtubesupportrans[i];
1667 }
cd2243fb 1668 for(Int_t j=0; j<2; j++){
1669 delete localcoolingtubevect[j];
1670 delete localcoolingtubetrans[j];
bf210566 1671 }
9b0c60ab 1672 delete endladdermountingblockrot;
bf210566 1673 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
bf210566 1674 for(Int_t i=0; i<fgkflexnumber; i++){
1675 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1676 delete localflexmatrix[i][j];
1677 delete [] localflexmatrix[i];
1678 }
9b0c60ab 1679 delete localendlladdercoolingtuberot;
1680 for(Int_t i=0; i<2; i++){
cd2243fb 1681 for(Int_t j=0; j<2; j++)
1682 delete localendlladdercoolingtubetrans[i][j];
9b0c60ab 1683 delete [] localendlladdercoolingtubetrans[i];
1684 }
1685
bf210566 1686 delete localflexrot;
1687 delete localendflexrot;
1688 delete localendflexmatrix;
1689 for(Int_t i=0; i<fgkladdernumber; i++){
1690 delete localladdermothertrans[i];
1691 delete localladdermothercombitrans[i];
1692 }
1693 delete localladdermotherrot;
1694 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1695 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1696 delete localendladdercarbonfiberjunctionmatrix[i][j];
1697 delete localendladdercarbonfiberjunctionrot[i][j];
1698 delete localendladdercarbonfiberjunctiontrans[i][j];
1699 }
1700 delete [] localendladdercarbonfiberjunctionmatrix[i];
1701 delete [] localendladdercarbonfiberjunctionrot[i];
1702 delete [] localendladdercarbonfiberjunctiontrans[i];
1703 delete localendladdercarbonfiberjunctionglobalrot[i];
1704 delete localendladdercarbonfiberjunctionglobaltrans[i];
1705 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1706 }
9b0c60ab 1707 for(Int_t i=0; i<2; i++){
1708 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1709 delete [] localendladdercooltubetrans[i];
1710 }
1711 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1712 delete localendladdercarbonfibertrans[i];
1713 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1714 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1715 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1716 delete localladdercablecombitransmatrix[i][j];
1717 delete []localladdercablecombitransmatrix[i];
1718 }
9b0c60ab 1719 delete localendladdercliprot;
1720 delete localendladdercliptrans;
bf210566 1721 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1722 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1723 delete localladdercablehmatrix[i][j];
1724 delete []localladdercablehmatrix[i];
1725 }
1726 delete laddercablerot;
1727 delete laddercabletrans;
1728 delete laddercablecombitrans;
1729 delete localladdercablessdmodulematrix;
1730 delete localssdsensorrot;
1731 for(Int_t i=0; i<2; i++){
1732 delete localssdsensortrans[i];
1733 delete localssdsensorcombitrans[i];
1734 }
1735 for(Int_t i=0; i<fgklayernumber; i++){
1736 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1737 delete locallayerrot[i][j];
1738 delete locallayertrans[i][j];
1739 delete locallayercombitrans[i][j];
1740 }
1741 delete [] locallayerrot[i];
1742 delete [] locallayertrans[i];
1743 delete [] locallayercombitrans[i];
1744 delete localbeamaxistrans[i];
1745 }
1746 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1747 for(Int_t i=0; i<fgkladdernumber; i++){
1748 for(Int_t j=0; j<fgkladdernumber; j++)
1749 delete ladderglobalmatrix[i][j];
1750 delete [] ladderglobalmatrix[i];
1751 }
1752 /////////////////////////////////////////////////////////////
1753 fTransformationMatrices = kTRUE;
d7599219 1754}
bf210566 1755///////////////////////////////////////////////////////////////////////////////
1756void AliITSv11GeometrySSD::CreateBasicObjects(){
1757 /////////////////////////////////////////////////////////////
1758 // Method generating the Objects of SSD Geometry
1759 /////////////////////////////////////////////////////////////
1760 // SSD Sensor
1761 ///////////////////////////////////
1762 SetSSDSensor();
1763 /////////////////////////////////////////////////////////////
1764 // Carbon Fiber Support
1765 /////////////////////////////////////////////////////////////
1766 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1767 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1768 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1769 /////////////////////////////////////////////////////////////
bf210566 1770 // Carbon Fiber Junction
44285dfa 1771 /////////////////////////////////////////////////////////////
ca86fdb4 1772 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
bf210566 1773 /////////////////////////////////////////////////////////////
1774 // Carbon Fiber Lower Support
1775 /////////////////////////////////////////////////////////////
1776 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1777 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1778 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1779 /////////////////////////////
1780 // SSD Sensor Support
1781 /////////////////////////////
1782 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1783 new TGeoVolume*[fgkssdsensorsupportnumber];
44285dfa 1784 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
bf210566 1785 fgkSSDSensorSideSupportThickness[1]};
1786 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1787 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1788 fgkSSDSensorSideSupportHeight[i],
1789 fgkSSDSensorSideSupportWidth,
1790 sidesupporthickness);
1791 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1792 fgkSSDSensorCenterSupportHeight[i],
1793 fgkSSDSensorCenterSupportWidth,
1794 sidesupporthickness);
1795 }
1796 /////////////////////////////////////////////////////////////
1797 // SSD Cooling Tube Support
1798 /////////////////////////////////////////////////////////////
3c057f23 1799 Int_t edgesnumber = 3;
bf210566 1800 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1801 /////////////////////////////////////////////////////////////
1802 // SSD Hybrid
1803 /////////////////////////////////////////////////////////////
1804 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1805 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1806 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1807 /////////////////////////////////////////////////////////////
1808 // SSD Cooling Block System
1809 /////////////////////////////////////////////////////////////
1810 fssdcoolingblocksystem = GetCoolingBlockSystem();
1811 /////////////////////////////////////////////////////////////
1812 // SSD Cooling Tube
1813 /////////////////////////////////////////////////////////////
cd2243fb 1814 CreateCoolingTubes();
bf210566 1815 /////////////////////////////////////////////////////////////
1816 // SSD Flex
1817 /////////////////////////////////////////////////////////////
1818 fssdstiffenerflex = GetSSDStiffenerFlex();
1819 fssdendflex = GetSSDEndFlex();
1820 ///////////////////////////////////
1821 // End Ladder Carbon Fiber Junction
1822 ///////////////////////////////////
1823 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1824 fendladdercarbonfiberjunction[i] =
1825 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1826 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1827 fendladdercarbonfiberjunction[i][0] =
ca86fdb4 1828 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
bf210566 1829 fendladdercarbonfiberjunction[i][1] =
ca86fdb4 1830 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
bf210566 1831 }
1832 ///////////////////////////////////
1833 // End Ladder Mounting Block
1834 ///////////////////////////////////
1835 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1836 ///////////////////////////////////
1837 // End Ladder Mounting Block
1838 ///////////////////////////////////
1839 fendladdermountingblockclip = GetMountingBlockClip();
1840 ///////////////////////////////////
1841 // Ladder Support
1842 ///////////////////////////////////
1843 TList* laddersupportlist = GetMountingBlockSupport(20);
1844 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1845 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1846 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1847 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
bf210566 1848 /////////////////////////////////////////////////////////////
1849 // Deallocating memory
44285dfa 1850 /////////////////////////////////////////////////////////////
bf210566 1851 delete carbonfibersupportlist;
1852 delete carbonfiberlowersupportlist;
1853 delete ssdhybridcomponentslist;
9b0c60ab 1854 delete laddersupportlist;
44285dfa 1855 /////////////////////////////////////////////////////////////
bf210566 1856 fBasicObjects = kTRUE;
1857}
1858/////////////////////////////////////////////////////////////////////////////////
1859void AliITSv11GeometrySSD::SetSSDSensor(){
1860 ////////////////////////////////////////////////////////////////
1861 // Method generating SSD Sensors: it sets the private variables
1862 // fSSDSensor5, fSSDSensor6
1863 ////////////////////////////////////////////////////////////////
44285dfa 1864 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1865 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1866 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
44285dfa 1867 0.5*ssdsensitivewidth,
bf210566 1868 0.5*fgkSSDSensorHeight,
1869 0.5*ssdsensitivelength);
1870 TGeoVolume* ssdsensorsensitiveLay5 =
02d4acf9 1871 new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1872 TGeoVolume* ssdsensorsensitiveLay6 =
02d4acf9 1873 new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1874 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1875 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
44285dfa 1876 TGeoBBox* ssdsensorinsensitiveshape[2];
1877 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1878 0.5*fgkSSDSensorInsensitiveWidth,
bf210566 1879 0.5*fgkSSDSensorHeight,
1880 0.5*fgkSSDSensorLength);
44285dfa 1881 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
44285dfa 1882 0.5*ssdsensitivewidth,
bf210566 1883 0.5*fgkSSDSensorHeight,
1884 0.5*fgkSSDSensorInsensitiveWidth);
44285dfa 1885 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1886 "SSDSensorInsensitive2"};
44285dfa 1887 TGeoVolume* ssdsensorinsensitive[2];
1888 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1889 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1890 fSSDSensorMedium);
1891 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1892 }
bf210566 1893 /////////////////////////////////////////////////////////////
1894 // Virtual Volume containing SSD Sensor
1895 /////////////////////////////////////////////////////////////
1896 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1897 0.5*fgkSSDSensorWidth,
1898 0.5*fgkSSDSensorHeight,
1899 0.5*fgkSSDSensorLength);
ef9451a3 1900 fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
bf210566 1901 fSSDAir);
ef9451a3 1902 fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
bf210566 1903 fSSDAir);
1904 /////////////////////////////////////////////////////////////
1905 for(Int_t i=0; i<4; i++){
1906 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1907 ssdsensorinsensitive[1],i<2?1:2,
1908 new TGeoTranslation(
1909 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1910 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1911 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1912 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1913 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
44285dfa 1914 ssdsensorinsensitive[1],i<2?1:2,
bf210566 1915 new TGeoTranslation(
1916 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1917 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1918 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1919 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1920 }
1921 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1922 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1923}
bf210566 1924///////////////////////////////////////////////////////////////////////////////
1925TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1926 /////////////////////////////////////////////////////////////
1927 // Method generating the Carbon Fiber Support
1928 /////////////////////////////////////////////////////////////
1929 const Int_t kvertexnumber = 4;
1930 const Int_t kshapesnumber = 2;
1931 TVector3** vertexposition[kshapesnumber];
1932 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1933 Double_t carbonfibersupportxaxisEdgeproj =
1934 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1935 * TMath::DegToRad());
1936 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1937 / fgkCarbonFiberSupportXAxisLength);
1938 /////////////////////
1939 //Vertex Positioning
1940 ////////////////////
1941 vertexposition[0][0] = new TVector3();
1942 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1943 fgkCarbonFiberSupportYAxisLength);
1944 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1945 carbonfibersupportxaxisEdgeproj
1946 * TMath::Tan(theta));
1947 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1948 - carbonfibersupportxaxisEdgeproj,
1949 fgkCarbonFiberSupportYAxisLength
1950 - vertexposition[0][2]->Y());
1951 ////////////////////////////////////////////////////
1952 //Setting the parameters for Isometry Transformation
1953 ////////////////////////////////////////////////////
1954 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1955 + fgkCarbonFiberSupportTopEdgeDist[0]
1956 + fgkCarbonFiberSupportWidth);
1957 Double_t* param = new Double_t[4];
1958 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1959 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
160835d5 1960 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1961 (GetReflection(vertexposition[0][j],param))->Y());
a6e0ebfe 1962 const char* carbonfibersupportshapename[kshapesnumber] =
bf210566 1963 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
a6e0ebfe 1964 const char* carbonfibersupportname[kshapesnumber] =
bf210566 1965 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1966 TGeoArb8* carbonfibersupportshape[kshapesnumber];
1967 TGeoVolume* carbonfibersupport[kshapesnumber];
1968 TList* carbonfibersupportlist = new TList();
1969 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1970 Double_t carbonfibersupportheight =
1971 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1972 *TMath::DegToRad());
1973 for(Int_t i = 0; i< kshapesnumber; i++){
1974 carbonfibersupportshape[i] =
1975 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1976 carbonfibersupportshapename[i],i==0 ? 1: -1);
1977 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1978 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1979 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1980 carbonfibersupportlist->Add(carbonfibersupport[i]);
1981 }
1982 /////////////////////////////////////////////////////////////
1983 // Deallocating memory
1984 /////////////////////////////////////////////////////////////
1985 for(Int_t i=0; i< kshapesnumber; i++){
1986 for(Int_t j=0; j< kvertexnumber; j++)
1987 delete vertexposition[i][j];
1988 delete [] vertexposition[i];
1989 }
1990 delete [] param;
44285dfa 1991 /////////////////////////////////////////////////////////////
bf210566 1992 return carbonfibersupportlist;
d7599219 1993}
1994/////////////////////////////////////////////////////////////////////////////////
bf210566 1995TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 1996 /////////////////////////////////////////////////////////////
bf210566 1997 // Method generating SSD Carbon Fiber Junction
44285dfa 1998 /////////////////////////////////////////////////////////////
bf210566 1999 const Int_t kvertexnumber = 6;
2000 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
d4ff3e0a 2001 Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
2002 * TMath::DegToRad()),-1.,0.,0.};
bf210566 2003 TVector3* vertex[kvertexnumber];
2004 vertex[0] = new TVector3();
2005 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2006 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2007 * TMath::DegToRad()),
2008 fgkCarbonFiberJunctionEdge[0]
2009 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
2010 * TMath::DegToRad()));
2011 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
2012 fgkCarbonFiberJunctionEdge[1]);
2013 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
2014 vertex[1] = GetReflection(vertex[5],reflectionparam);
2015 vertex[2] = GetReflection(vertex[4],reflectionparam);
2016 Double_t xvertexpoints[6], yvertexpoints[6];
2017 for(Int_t i=0; i<kvertexnumber; i++)
2018 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
2019 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2020 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
2021 carbonfiberjunctionshape->DefineSection(1,0.5*width);
2022 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
2023 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
2024 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
2025 /////////////////////////////////////////////////////////////
2026 // Deallocating memory
2027 /////////////////////////////////////////////////////////////
2028 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
2029 /////////////////////////////////////////////////////////////
2030 return carbonfiberjunction;
2031}
2032////////////////////////////////////////////////////////////////////////////////
2033TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
2034 /////////////////////////////////////////////////////////////
2035 // Method generating the Carbon Fiber Lower Support
2036 /////////////////////////////////////////////////////////////
2037 const Int_t kvertexnumber = 4;
2038 const Int_t kshapesnumber = 2;
2039 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
2040 fgkCarbonFiberLowerSupportWidth};
2041 TVector3** vertexposition[kshapesnumber];
2042 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2043 new TVector3*[kvertexnumber];
2044 //First Shape Vertex Positioning
2045 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2046 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
2047 - fgkCarbonFiberLowerSupportLowerLenght);
2048 vertexposition[0][2] = new TVector3();
2049 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
2050 //Second Shape Vertex Positioning
2051 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
2052 - fgkCarbonFiberLowerSupportVolumePosition[0])
2053 / fgkCarbonFiberTriangleLength);
2054 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2055 vertexposition[0][0]->X()*TMath::Tan(theta)
2056 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2057 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2058 vertexposition[0][1]->X()*TMath::Tan(theta)
2059 + fgkCarbonFiberLowerSupportVolumePosition[0]);
2060 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2061 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
2062 fgkCarbonFiberLowerSupportVolumePosition[1]);
a6e0ebfe 2063 const char* carbonfiberlowersupportshapename[kshapesnumber] =
bf210566 2064 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
a6e0ebfe 2065 const char* carbonfiberlowersupportname[kshapesnumber] =
bf210566 2066 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2067 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2068 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2069 TList* carbonfiberlowersupportlist = new TList();
2070 for(Int_t i = 0; i< kshapesnumber; i++){
2071 carbonfiberlowersupportshape[i] =
2072 GetArbShape(vertexposition[i],width,
2073 fgkCarbonFiberLowerSupportHeight,
2074 carbonfiberlowersupportshapename[i]);
2075 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2076 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2077 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2078 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2079 }
2080 /////////////////////////////////////////////////////////////
2081 // Deallocating memory
2082 /////////////////////////////////////////////////////////////
2083 for(Int_t i=0; i< kshapesnumber; i++){
2084 for(Int_t j=0; j< kvertexnumber; j++)
2085 delete vertexposition[i][j];
2086 delete [] vertexposition[i];
2087 }
2088 /////////////////////////////////////////////////////////////
2089 return carbonfiberlowersupportlist;
2090}
2091///////////////////////////////////////////////////////////////////////////////
2092TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
5cb5bc3d 2093 Double_t width, const Double_t* thickness)const{
bf210566 2094 /////////////////////////////////////////////////////////////
2095 // Method generating the Sensor Support
2096 /////////////////////////////////////////////////////////////
2097 const Int_t kvertexnumber = 6;
2098 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2099 TVector3* vertexposition[kvertexnumber];
2100 vertexposition[0] = new TVector3();
2101 vertexposition[1] = new TVector3(0.0,length);
2102 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2103 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2104 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2105 vertexposition[5] = new TVector3(vertexposition[4]->X());
2106 Double_t xvertexpoints[6], yvertexpoints[6];
2107 for(Int_t i=0; i<kvertexnumber; i++)
2108 xvertexpoints[i] = vertexposition[i]->X(),
2109 yvertexpoints[i] = vertexposition[i]->Y();
2110 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2111 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2112 ssdsensorsupportshape->DefineSection(1,0.5*width);
2113 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2114 ssdsensorsupportshape,fSSDSensorSupportMedium);
2115 /////////////////////////////////////////////////////////////
2116 // Deallocating memory
2117 /////////////////////////////////////////////////////////////
2118 for (Int_t i=0; i<kvertexnumber; i++)
2119 delete vertexposition[i];
2120 /////////////////////////////////////////////////////////////
2121 return ssdsensorsupport;
2122}
2123////////////////////////////////////////////////////////////////////////////////
2124TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2125 /////////////////////////////////////////////////////////////
2126 // Method generating the Cooling Tube Support
2127 /////////////////////////////////////////////////////////////
2128 if(nedges%2!=0) nedges--;
2129 const Int_t kvertexnumber = nedges+5;
2130 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2131 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2132 Double_t angle = 90.+phi;
2133 Double_t psi = 90.-phi;
2134 ///////////////////////////////////////
2135 // Vertex Positioning for TGeoXTru
2136 ///////////////////////////////////////
2137 TVector3** vertexposition = new TVector3*[kvertexnumber];
cd2243fb 2138
3c057f23 2139 Double_t Router = fgkCoolingTubeSupportRmin/CosD(phi/nedges); // Recalc inner radius so that tube fits inside
cd2243fb 2140 vertexposition[0] = new TVector3(Router*CosD(angle),
2141 Router*SinD(angle));
bf210566 2142 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2143 fgkCoolingTubeSupportRmax*SinD(angle));
2144 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2145 fgkCoolingTubeSupportRmax);
2146 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2147 fgkCoolingTubeSupportRmax);
2148 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2149 vertexposition[1]->Y());
cd2243fb 2150
bf210566 2151 for(Int_t i=0; i<nedges; i++)
2152 vertexposition[i+5] =
cd2243fb 2153 new TVector3(Router*CosD(psi+i*(2.*phi/nedges)),
2154 Router*SinD(psi+i*(2.*phi/nedges)));
bf210566 2155 ///////////////////////////////////////////////////////////////////////
2156 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2157 ///////////////////////////////////////////////////////////////////////
2158 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2159 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2160 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2161 for(Int_t i=0; i<kvertexnumber; i++){
2162 xvertexpoints[i] = vertexposition[i]->X();
2163 yvertexpoints[i] = vertexposition[i]->Y();
2164 }
2165 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2166 yvertexpoints);
2167 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2168 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2169 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2170 coolingtubesupportarcshape,
2171 fSSDTubeHolderMedium);
2172 coolingtubesupportarc->SetLineColor(fColorG10);
2173 //////////////////////////////////////////////////////////////////////////
2174 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2175 //////////////////////////////////////////////////////////////////////////
2176 TGeoTubeSeg* coolingtubesupportsegshape =
2177 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2178 fgkCoolingTubeSupportRmax,
2179 0.5*fgkCoolingTubeSupportWidth,
2180 phi,360-phi);
2181 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2182 coolingtubesupportsegshape,
2183 fSSDTubeHolderMedium);
2184 coolingtubesupportseg->SetLineColor(fColorG10);
2185 //////////////////////////////////////////////////////////////////////////
2186 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2187 //////////////////////////////////////////////////////////////////////////
2188 Double_t* boxorigin = new Double_t[3];
2189 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2190 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2191 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2192 0.5*fgkCoolingTubeSupportHeight,
2193 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2194 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2195 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2196 coolingtubesupportbox->SetLineColor(fColorG10);
2197 //////////////////////////////////////////////////////////////////////////
2198 // Cooling Tube for Cooling Tube Support
2199 //////////////////////////////////////////////////////////////////////////
2200 TGeoXtru* coolingtubearcshape[2];
2201 coolingtubearcshape[0] = new TGeoXtru(2);
2202 Double_t* xvert = new Double_t[nedges+2];
2203 Double_t* yvert = new Double_t[nedges+2];
2204 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2205 ////////////////////////////////////////
2206 // Positioning the vertices for TGeoXTru
2207 ////////////////////////////////////////
2208 xvert[0] = 0., yvert[0] = 0.;
2209 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2210 for(Int_t i=0; i< nedges; i++)
2211 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2212 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2213 ////////////////////////////////////////
2214 // Defining TGeoXTru PolyGone
2215 ////////////////////////////////////////
2216 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2217 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2218 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2219 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2220 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2221 TGeoVolume* coolingtubearc[2];
2222 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2223 coolingtubearcshape[0],fSSDCoolingTubeWater);
2224 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2225 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2226 coolingtubearc[0]->SetLineColor(fColorWater);
2227 coolingtubearc[1]->SetLineColor(fColorPhynox);
2228 ////////////////////////////////////////////
2229 // Defining TGeoTubeSeg Part of Cooling Tube
2230 ////////////////////////////////////////////
2231 TGeoTubeSeg* coolingtubesegshape[2];
2232 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2233 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2234 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2235 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2236 TGeoVolume* coolingtubeseg[2];
2237 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2238 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2239 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2240 coolingtubesegshape[1],fSSDCoolingTubeWater);
2241 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2242 coolingtubeseg[1]->SetLineColor(fColorWater);
2243 /////////////////////////////////////////////////////////////
2244 // Virtual Volume containing Cooling Tube Support
2245 /////////////////////////////////////////////////////////////
2246 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2247 const Int_t kvirtualvertexnumber = 8;
2248 TVector3* virtualvertex[kvirtualvertexnumber];
2249 ////////////////////////////////////////
2250 // Positioning the vertices for TGeoXTru
2251 ////////////////////////////////////////
2252 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2253 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2254 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2255 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2256 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2257 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2258 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2259 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2260 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2261 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2262 xmothervertex[i] = virtualvertex[i]->X(),
2263 ymothervertex[i] = virtualvertex[i]->Y();
2264 ////////////////////////////////////////
2265 // Defining TGeoXTru PolyGone
2266 ////////////////////////////////////////
2267 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2268 ymothervertex);
2269 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2270 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
cd2243fb 2271 /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2272 virtualCoolingTubeSupportShape,fSSDAir); */
2273 TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
2274
bf210566 2275 ////////////////////////////////////////
2276 // Positioning Volumes in Virtual Volume
2277 ////////////////////////////////////////
2278 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2279 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2280 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2281 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2282 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
cd2243fb 2283 //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2284 //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2285 //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2286 //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
bf210566 2287 /////////////////////////////////////////////////////////////
2288 // Deallocating memory
2289 /////////////////////////////////////////////////////////////
2290 delete [] vertexposition;
3e008bd7 2291 delete [] xvertexpoints;
2292 delete [] yvertexpoints;
2293 delete [] xvert;
2294 delete [] yvert;
bf210566 2295 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2296 delete virtualvertex[i];
2297 /////////////////////////////////////////////////////////////
2298 return virtualcoolingtubesupport;
2299}
2300/////////////////////////////////////////////////////////////////////////////////
2301TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2302 /////////////////////////////////////////////////////////////
2303 // Method generating List containing SSD Hybrid Components
2304 /////////////////////////////////////////////////////////////
2305 TList* ssdhybridlist = new TList();
2306 const Int_t kssdstiffenernumber = 2;
2307 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2308 - 2.*fgkSSDModuleStiffenerPosition[1]
2309 - fgkSSDStiffenerWidth;
2310 Double_t ssdchipcablesradius[kssdstiffenernumber];
2311 for(Int_t i=0; i<kssdstiffenernumber; i++)
2312 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2313 - fgkSSDChipCablesHeight[0]
2314 - fgkSSDChipCablesHeight[1]);
2315 /////////////////////////////////////////////////////////////
2316 // Mother Volumes Containers
2317 /////////////////////////////////////////////////////////////
2318 const Int_t kmothernumber = 2;
3cf6a656 2319 const Int_t kmothervertexnumber = 8;
bf210566 2320 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2321 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
3cf6a656 2322
2323 TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
2324 TGeoVolume* ssdhybridmother[kmothernumber][2];
2325
2326 TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
2327 TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
2328 TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
2329
bf210566 2330 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2331 for(Int_t i=0; i<kmothernumber; i++){
3cf6a656 2332 xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
2333 ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
2334 xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
2335 ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2336 -fgkSSDChipCablesHeight[i+2];
2337
2338 xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
2339 ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
2340 xmothervertex[i][3] = xmothervertex[i][2];
2341 ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1];
2342
2343 xmothervertex[i][4] = xmothervertex[i][2]-0.4;
2344 ymothervertex[i][4] = ymothervertex[i][3];
2345 xmothervertex[i][5] = xmothervertex[i][4];
2346 ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i];
2347
2348 xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
2349 ymothervertex[i][6] = ymothervertex[i][5];
2350
2351 xmothervertex[i][7] = xmothervertex[i][6];
2352 ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
3cf6a656 2353 TGeoXtru *shape = new TGeoXtru(2);
2354 shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
2355 shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
2356 shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
2357 ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
2358 ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
2359 ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
bf210566 2360 }
2361 /////////////////////////////////////////////////////////////
2362 // SSD Stiffener
2363 /////////////////////////////////////////////////////////////
2364 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2365 0.5*fgkSSDStiffenerLength,
ca86fdb4 2366 0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
bf210566 2367 0.5*fgkSSDStiffenerHeight);
2368 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2369 fSSDStiffenerMedium);
2370 ssdstiffener->SetLineColor(fColorStiffener);
3cf6a656 2371
bf210566 2372////////////////////////////
2373// Capacitor 0603-2200 nF
2374///////////////////////////
2375 const Int_t knapacitor0603number = 5;
78e34526 2376 TGeoBBox* capacitor0603mothershape = new TGeoBBox("Capacitor0603MotherShape",
2377 0.5*fgkSSDCapacitor0603Length + fgkSSDCapacitor0603CapLength,
2378 0.5*fgkSSDCapacitor0603Width,
2379 0.5*fgkSSDCapacitor0603Height);
2380 TGeoVolume* capacitor0603mother = new TGeoVolume("Capacitor0603Mother",capacitor0603mothershape,
2381 fSSDAir);
2382
bf210566 2383 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
3cf6a656 2384 0.5*fgkSSDCapacitor0603Length,
78e34526 2385 0.5*fgkSSDCapacitor0603Width,
3cf6a656 2386 0.5*fgkSSDCapacitor0603Height);
bf210566 2387 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2388 fSSDStiffener0603CapacitorMedium);
2389 capacitor0603->SetLineColor(fColorAl);
78e34526 2390 TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.);
2391 capacitor0603mother->AddNode(capacitor0603,1,cap0603trans);
2392
2393 TGeoBBox* capacitor0603capshape = new TGeoBBox("Capacitor0603CapShape",
2394 0.5*fgkSSDCapacitor0603CapLength,
2395 0.5*fgkSSDCapacitor0603Width,
2396 0.5*fgkSSDCapacitor0603Height);
2397 TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape,
2398 fSSDStiffenerCapacitorCapMedium);
2399 capacitor0603cap->SetLineColor(fColorNiSn);
2400 TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.);
2401 capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1);
2402 TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.);
2403 capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2);
2404
3cf6a656 2405
2406 TGeoVolume* ssdchip = GetSSDChip();
2407
2408 const Int_t knedges = 5;
2409 TGeoVolume *ssdchipcables[2];
2410
bf210566 2411 for(Int_t i=0; i<kmothernumber; i++){
3cf6a656 2412 for(Int_t j=0; j<kssdstiffenernumber; j++){
2413 ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
2414 for(Int_t k=1; k<knapacitor0603number+1; k++){
78e34526 2415 ssdhybridmother[i][j]->AddNode(capacitor0603mother,k,
3cf6a656 2416 new TGeoCombiTrans("",
2417 -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
2418 -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
2419 (k-3.)/6*fgkSSDStiffenerLength,
2420 hybridmotherrotInv));
2421 }
2422 }
2423
2424 GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
2425 for(Int_t k=0; k<fgkSSDChipNumber; k++){
2426 TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
2427 - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
2428 - fgkSSDChipCablesHeight[i+2],
2429 (k+0.5-fgkSSDChipNumber/2)*
2430 (fgkSSDChipLength + fgkSSDChipSeparationLength));
2431 TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
2432 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
2433 (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
2434 hybridmotherrotInv);
bf210566 2435 for(Int_t j=0; j<kssdstiffenernumber; j++){
3cf6a656 2436 ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
2437 ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
2438 }
2439 }
2440 // Final placement by assembly
2441 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
2442 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
2443 ssdhybridlist->Add(ssdhybridassembly[i]);
bf210566 2444 }
3cf6a656 2445 /////////////////////////////////////////////////////////////
2446 // Mother Volume Containing Capacitor Part
2447 /////////////////////////////////////////////////////////////
bf210566 2448 const Int_t kcapacitormothernumber = 8;
2449 Double_t xcapacitorvertex[kcapacitormothernumber];
2450 Double_t ycapacitorvertex[kcapacitormothernumber];
2451 ///////////////////////
2452 // Setting the vertices
2453 ///////////////////////
2454 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2455 xcapacitorvertex[1] = xcapacitorvertex[0];
2456 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2457 xcapacitorvertex[3] = xcapacitorvertex[2];
2458 xcapacitorvertex[4] = xcapacitorvertex[0];
2459 xcapacitorvertex[5] = xcapacitorvertex[0];
2460 xcapacitorvertex[6] = -xcapacitorvertex[0];
2461 xcapacitorvertex[7] = xcapacitorvertex[6];
2462 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2463 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2464 ycapacitorvertex[2] = ycapacitorvertex[1];
2465 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2466 ycapacitorvertex[4] = ycapacitorvertex[3];
2467 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2468 ycapacitorvertex[6] = ycapacitorvertex[5];
2469 ycapacitorvertex[7] = ycapacitorvertex[0];
2470 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2471 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2472 ycapacitorvertex);
2473 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2474 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
ca86fdb4 2475// TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2476// fSSDAir);
2477 TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
d7599219 2478////////////////////////////
bf210566 2479// Connector
d7599219 2480///////////////////////////
78e34526 2481 const Int_t kssdconnectorlayernumber = 3;
2482 TGeoBBox* ssdconnectorshape[kssdconnectorlayernumber];
2483 Double_t ssdConnectorThickness[kssdconnectorlayernumber]={fgkSSDConnectorAlHeight,fgkSSDConnectorNiHeight,fgkSSDConnectorSnHeight};
2484 /*
bf210566 2485 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2486 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2487 + fgkSSDConnectorAlHeight};
78e34526 2488 */
2489 Double_t ssdconnectororigin[3] = {0,0,0.5*fgkSSDStiffenerHeight};
2490 const char* ssdconnectorname[kssdconnectorlayernumber] = {"SSDConnectorAl","SSDConnectorNi","SSDConnectorSn"};
2491 TGeoMedium *ssdConnectorMedium[kssdconnectorlayernumber]={fSSDAlTraceFlexMedium,fSSDStiffenerConnectorMedium,fSSDSn};
2492 TGeoVolume* ssdconnector[kssdconnectorlayernumber];
2493 for(Int_t i=0; i<kssdconnectorlayernumber; i++){
2494 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
bf210566 2495 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2496 0.5*fgkSSDConnectorWidth,
78e34526 2497 0.5*ssdConnectorThickness[i],
2498 ssdconnectororigin);
2499 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
bf210566 2500 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
78e34526 2501 ssdConnectorMedium[i]);
2502 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorNiSn);
bf210566 2503 }
78e34526 2504 const Int_t kssdconnectornumber = 4;
2505 TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
bf210566 2506 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2507 + fgkSSDConnectorPosition[0]
2508 - fgkSSDConnectorSeparation
2509 - 1.5*fgkSSDConnectorLength,
2510 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2511 - fgkSSDConnectorPosition[1]
2512 - ssdconnectorshape[0]->GetDY(),0.0);
2513 ssdconnectortrans[1] = new TGeoTranslation(
2514 - ssdstiffenershape->GetDX()
2515 + fgkSSDConnectorPosition[0]
2516 - 0.5*fgkSSDConnectorLength,
2517 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2518 - fgkSSDConnectorPosition[1]
2519 - ssdconnectorshape[0]->GetDY(),0.0);
2520 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2521 - fgkSSDConnectorPosition[0]
2522 + fgkSSDConnectorSeparation
2523 + 1.5*fgkSSDConnectorLength,
2524 -(ssdstiffenershape->GetDY()
2525 - fgkSSDConnectorPosition[1]
2526 - ssdconnectorshape[0]->GetDY()),0.0);
2527 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2528 - fgkSSDConnectorPosition[0]
2529 + 0.5*fgkSSDConnectorLength,
2530 -(ssdstiffenershape->GetDY()
2531 - fgkSSDConnectorPosition[1]
2532 - ssdconnectorshape[0]->GetDY()),0.0);
78e34526 2533 for(Int_t i=0; i<kssdconnectornumber; i++) {
2534 Int_t nlay = kssdconnectorlayernumber - 1;
2535 if (i == 1 || i == 2)
2536 nlay++;
2537 for(Int_t j=0; j<nlay; j++)
2538 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2539 }
bf210566 2540////////////////////////////
2541// Capacitor 1812-330 nF
2542///////////////////////////
78e34526 2543// Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2544 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2545 0.5*fgkSSDCapacitor1812Length,
2546 0.5*fgkSSDCapacitor1812Width,
78e34526 2547 0.5*fgkSSDCapacitor1812Height);
2548 // ssdcapacitor1812origin);
44285dfa 2549 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2550 fSSDStiffener1812CapacitorMedium);
2551 capacitor1812->SetLineColor(fColorAl);
bf210566 2552 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2553 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
78e34526 2554 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
bf210566 2555 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
78e34526 2556
2557 TGeoBBox* capacitor1812capshape = new TGeoBBox("Capacitor1812CapShape",
2558 0.5*fgkSSDCapacitor1812CapLength, 0.5*fgkSSDCapacitor1812Width,
2559 0.5*fgkSSDCapacitor1812Height);
2560 TGeoVolume* capacitor1812cap = new TGeoVolume("Capacitor1812Cap",capacitor1812capshape,
2561 fSSDStiffenerCapacitorCapMedium);
2562 capacitor1812cap->SetLineColor(fColorNiSn);
2563 TGeoTranslation* capacitor1812captrans1 = new TGeoTranslation(
2564 - capacitor1812shape->GetDX() - capacitor1812capshape->GetDX(),
2565 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2566 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2567 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2568 ssdhybridcapacitormother->AddNode(capacitor1812cap,1,capacitor1812captrans1);
2569 TGeoTranslation* capacitor1812captrans2 = new TGeoTranslation(
2570 capacitor1812shape->GetDX() + capacitor1812capshape->GetDX(),
2571 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2572 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2573 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2574 ssdhybridcapacitormother->AddNode(capacitor1812cap,2,capacitor1812captrans2);
2575
d7599219 2576////////////////////////////
2577//Hybrid Wire
2578////////////////////////////
44285dfa 2579 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2580 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2581 - fgkSSDConnectorSeparation;
44285dfa 2582 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2583 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
60e55aee 2584 Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2585
44285dfa 2586 Double_t wireangle = TMath::ATan(wirex/wirey);
2587 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2588 fgkSSDWireRadius, 0.5*ssdwireradius);
2589 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2590 fSSDStiffenerHybridWireMedium);
2591 hybridwire->SetLineColor(fColorPhynox);
2592 TGeoCombiTrans* hybridwirecombitrans[2];
2593 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2594 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2595 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2596 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2597 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2598 ssdstiffenershape->GetDZ()
78e34526 2599 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight+fgkSSDConnectorSnHeight,
d7599219 2600 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2601 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2602 0.0,
2603 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2604 0.0,
2605 new TGeoRotation("HybridWireRot2",
2606 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2607 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2608 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2609 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2610 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2611 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2612 /////////////////////////////////////////////////////////////
bf210566 2613 // Deallocating memory
44285dfa 2614 /////////////////////////////////////////////////////////////
bf210566 2615 delete hybridwirecombitrans[0];
2616 delete hybridwirecombitrans[1];
bf210566 2617 return ssdhybridlist;
2618 /////////////////////////////////////////////////////////////
2619}
2620///////////////////////////////////////////////////////////////////////////////
2621TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2622 /////////////////////////////////////////////////////////////
2623 // SSD Cooling Block System
2624 /////////////////////////////////////////////////////////////
2625 // SSD Cooling Block and Cooling Tube Transformations
2626 /////////////////////////////////////////////////////////////
2627 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2628 localcoolingblockrot->SetAngles(0.,90.,0.);
535e8862 2629 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
bf210566 2630 TVector3* coolingblocktransvector;
78e34526 2631 coolingblocktransvector = new TVector3(fgkCoolingTubeSeparation,
bf210566 2632 fgkSSDSensorLength
2633 - 2.*fgkSSDModuleStiffenerPosition[1]
2634 - fgkSSDCoolingBlockWidth);
2635 const Int_t kcoolingblocktransnumber = 2;
2636 const Int_t kcoolingblocknumber = 4;
2637 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
bf210566 2638 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2639 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
bf210566 2640 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
535e8862 2641 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
78e34526 2642 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X(),//+2*coolingtubedistance,
535e8862 2643 j*coolingblocktransvector->Y(),
2644 - 0.5*(fgkSSDCoolingBlockHoleCenter
2645 + fgkCoolingTubeRmax));
2646 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
535e8862 2647 }
d7599219 2648 }
ca86fdb4 2649 TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
bf210566 2650 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2651 /////////////////////////////////////////////////////////////
2652 // Adding Cooling block to mother volume
2653 /////////////////////////////////////////////////////////////
3cf6a656 2654 for(Int_t i=0; i<kcoolingblocknumber; i++){
2655 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
d7599219 2656 }
bf210566 2657 /////////////////////////////////////////////////////////////
2658 // Deallocating memory
2659 /////////////////////////////////////////////////////////////
3cf6a656 2660 delete coolingblocktransvector;
2661 delete localcoolingblockrot;
2662
2663 return coolingsystemother;
d7599219 2664}
2665/////////////////////////////////////////////////////////////////////////////////
bf210566 2666TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2667 /////////////////////////////////////////////////////////////
bf210566 2668 // SSD Flex
44285dfa 2669 /////////////////////////////////////////////////////////////
bf210566 2670 const Int_t kssdflexlayernumber = 2;
2671 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2672 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2673 const Int_t kmothervertexnumber = 17;
2674 Double_t xmothervertex[kmothervertexnumber];
2675 Double_t ymothervertex[kmothervertexnumber];
2676 /////////////////////////////////////////////
2677 // Auxiliary variables for vertex positioning
2678 /////////////////////////////////////////////
2679 const Int_t kssdflexboxnumber = 5;
44285dfa 2680 Double_t ssdflexboxlength[kssdflexboxnumber];
2681 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2682 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2683 * fgkSSDChipSeparationLength
2684 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2685 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2686 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2687 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2688 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2689 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2690 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2691 - ssdflexboxlength[1];
44285dfa 2692 Double_t ssdflexboxwidth[kssdflexboxnumber];
2693 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2694 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2695 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2696 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2697 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2698 ///////////////////////
2699 // Setting the vertices
2700 ///////////////////////
2701 xmothervertex[0] = 0.0;
2702 xmothervertex[1] = xmothervertex[0];
2703 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2704 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2705 + ssdflexboxlength[4];
2706 xmothervertex[4] = xmothervertex[3];
2707 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2708 xmothervertex[6] = xmothervertex[5];
2709 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2710 xmothervertex[8] = xmothervertex[7];
2711 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2712 xmothervertex[10] = xmothervertex[9];
2713 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2714 xmothervertex[12] = xmothervertex[11];
2715 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2716 xmothervertex[14] = xmothervertex[13];
2717 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2718 xmothervertex[16] = xmothervertex[15];
2719 ymothervertex[0] = 0.0;
2720 ymothervertex[1] = fgkSSDFlexWidth[1];
2721 ymothervertex[2] = fgkSSDFlexWidth[0];
2722 ymothervertex[3] = ymothervertex[2];
2723 ymothervertex[4] = ymothervertex[0];
2724 ymothervertex[5] = ymothervertex[4];
2725 ymothervertex[6] = ssdflexboxwidth[2];
2726 ymothervertex[7] = ymothervertex[6];
2727 ymothervertex[8] = ymothervertex[0];
2728 ymothervertex[9] = ymothervertex[8];
2729 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2730 ymothervertex[11] = ymothervertex[10];
2731 ymothervertex[12] = ymothervertex[0];
2732 ymothervertex[13] = ymothervertex[12];
2733 ymothervertex[14] = ymothervertex[7];
2734 ymothervertex[15] = ymothervertex[14];
2735 ymothervertex[16] = ymothervertex[0];
2736 /////////////////////////////////////////////////////////////
2737 // First Mother Volume containing SSDFlex
2738 /////////////////////////////////////////////////////////////
2739 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2740 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2741 ymothervertex);
2742 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2743 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
ca86fdb4 2744 TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2745// TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2746// fSSDAir);
bf210566 2747 /////////////////////////////////////////////////////////////
2748 // SSDFlex Layer Shapes
2749 /////////////////////////////////////////////////////////////
2750 for(Int_t i=0; i<kssdflexlayernumber; i++){
2751 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2752 ymothervertex);
2753 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2754 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2755 }
2756 /////////////////////////////////////
2757 // Setting Layers into Mother Volume
2758 /////////////////////////////////////
2759 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2760 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2761 fSSDKaptonFlexMedium};
2762 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2763 "AlFlexLay2","KaptonFlexLay2"};
2764 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2765 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2766 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2767 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2768 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2769 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2770 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2771 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2772 + fgkSSDFlexHeight[1]));
2773 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2774 }
bf210566 2775 return ssdflexmother;
d7599219 2776}
2777/////////////////////////////////////////////////////////////////////////////////
bf210566 2778TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2779 /////////////////////////////////////////////////////////////
2780 // Method generating SSD End Flex
d7599219 2781 /////////////////////////////////////////
bf210566 2782 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2783 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2784 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2785 * TMath::DegToRad()*ssdflexradiusmax
2786 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 2787 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2788 - 0.1*fgkSSDFlexFullLength;
bf210566 2789 const Int_t knedges = 20;
2790 const Int_t karcnumber = 2;
2791 TVector3* vertexposition[karcnumber*(knedges+1)];
2792 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2793 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2794 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2795 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2796 - 90.0*TMath::DegToRad()};
2797 TVector3* referencetrans[karcnumber];
2798 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2799 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2800 radius[0]);
2801 referencetrans[1] = new TVector3(referencetrans[0]->X()
2802 + fgkSSDFlexLength[2],
2803 - fgkSSDStiffenerHeight);
2804for(Int_t i=0; i<karcnumber; i++){
2805 for(Int_t j=0; j<knedges+1; j++){
2806 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2807 radius[i]*SinD(angle[i]));
2808 angle[i] += deltangle[i]*(1.0-2.0*i);
2809 }
2810 }
2811 ///////////////////////
2812 // Setting the vertices
2813 ///////////////////////
2814 const Int_t kendflexlayernumber = 4;
2815 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2816 TVector3** vertex[kendflexlayernumber];
2817 for(Int_t i=0; i<kendflexlayernumber; i++)
2818 vertex[i] = new TVector3*[kendflexvertexnumber];
2819 TVector3* transvector[kendflexlayernumber+1];
2820 TVector3* deltatransvector = new TVector3();
2821 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2822 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2823 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2824 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2825 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2826 * CosD(fgkSSDFlexAngle),
2827 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2828 * SinD(fgkSSDFlexAngle),0.0);
2829 *transvector[i] = *transvector[i-1]+*deltatransvector;
2830 }
2831 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2832 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2833 for(Int_t i=0; i<karcnumber; i++){
2834 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2835 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2836 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2837 /radius[i];
2838 }
2839 }
2840 for(Int_t i=0; i<kendflexlayernumber; i++){
2841 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2842 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2843 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2844 if(j<(knedges+1)){
2845 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2846 vertexposition[j]->Y()*ratioradius[0][i+1]);
2847 vertex[i][j+2]->RotateZ(referenceangle[0]);
2848 *vertex[i][j+2] += *referencetrans[0];
2849 vertex[i][4*(knedges+1)-j+1] =
2850 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2851 vertexposition[j]->Y()*ratioradius[0][i]);
2852 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2853 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2854 }
2855 else{
2856
2857 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2858 vertexposition[j]->Y()*ratioradius[1][i+1]);
2859 vertex[i][j+2]->RotateZ(referenceangle[1]);
2860 *vertex[i][j+2] += *referencetrans[1];
2861 vertex[i][4*(knedges+1)-j+1] =
2862 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2863 vertexposition[j]->Y()*ratioradius[1][i]);
2864 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2865 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2866 }
2867 }
2868 }
44285dfa 2869 /////////////////////////////////////////////////////////////
bf210566 2870 // First Mother Volume containing SSDEndFlex
2871 /////////////////////////////////////////////////////////////
2872 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2873 Double_t xmothervertex[kendflexvertexnumber];
2874 Double_t ymothervertex[kendflexvertexnumber];
2875 xmothervertex[0] = vertex[0][0]->X();
2876 ymothervertex[0] = vertex[0][0]->Y();
2877 for(Int_t i=1; i<kendflexvertexnumber; i++){
2878 if(i<2*(knedges+1)+2){
2879 xmothervertex[i] = vertex[3][i]->X();
2880 ymothervertex[i] = vertex[3][i]->Y();
2881 }
2882 else{
2883 xmothervertex[i] = vertex[0][i]->X();
2884 ymothervertex[i] = vertex[0][i]->Y();
2885 }
2886 }
2887 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2888 xmothervertex,ymothervertex);
2889 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2890 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
0fb26117 2891// TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2892// ssdendflexmothershape,fSSDAir);
2893 TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
bf210566 2894 //////////////////////////////////////
2895 // End Flex TGeoXtru Layer Definition
2896 //////////////////////////////////////
2897 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2898 TGeoVolume* ssdendflex[kendflexlayernumber];
2899 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2900 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2901 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2902 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2903 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2904 fSSDKaptonFlexMedium};
2905 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2906 "AlEndFlexLay2","KaptonEndFlexLay2"};
2907 for(Int_t i=0; i<kendflexlayernumber; i++){
2908 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2909 xvertex[i][j] = vertex[i][j]->X();
2910 yvertex[i][j] = vertex[i][j]->Y();
2911 }
2912 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2913 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2914 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2915 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2916 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2917 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2918 ssdendflexmother->AddNode(ssdendflex[i],1);
2919 }
44285dfa 2920 /////////////////////////////////////////////////////////////
bf210566 2921 // Deallocating memory
44285dfa 2922 /////////////////////////////////////////////////////////////
bf210566 2923 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2924 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2925 for(Int_t i=0; i<kendflexlayernumber; i++){
2926 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2927 delete [] vertex[i];
2928 }
2929 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2930 delete deltatransvector;
44285dfa 2931 /////////////////////////////////////////////////////////////
6727e2db 2932 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 2933 return ssdendflexmother;
d7599219 2934}
9b0c60ab 2935///////////////////////////////////////////////////////////////////////////////
bf210566 2936TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 2937 /////////////////////////////////////////////////////////////
9b0c60ab 2938 // Method generating the Mounting Block
bf210566 2939 /////////////////////////////////////////////////////////////
9b0c60ab 2940 const Int_t kvertexnumber = 8;
2941 Double_t xvertex[kvertexnumber];
2942 Double_t yvertex[kvertexnumber];
2943 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2944 xvertex[1] = xvertex[0];
2945 xvertex[2] = -xvertex[0];
2946 xvertex[3] = xvertex[2];
2947 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2948 - fgkSSDMountingBlockLength[2]);
2949 xvertex[5] = xvertex[4];
2950 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2951 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2952 - fgkSSDMountingBlockScrewHoleRadius[0];
2953 xvertex[7] = xvertex[6];
2954 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 2955 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 2956 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2957 yvertex[2] = yvertex[1];
2958 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2959 yvertex[4] = yvertex[3];
2960 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2961 - fgkSSDMountingBlockHeight[0];
2962 yvertex[6] = yvertex[5];
2963 yvertex[7] = yvertex[0];
160835d5 2964
9b0c60ab 2965 ///////////////////////////////////////////////////////////////////////
2966 // TGeoXTru Volume definition for Mounting Block Part
2967 ///////////////////////////////////////////////////////////////////////
2968 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2969 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2970 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2971 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 2972 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 2973 ssdmountingblockshape,
2974 fSSDMountingBlockMedium);
2975 ssdmountingblock->SetLineColor(fColorG10);
2976 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2977 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2978 TGeoRotation* mountingblockrot = new TGeoRotation();
2979 mountingblockrot->SetAngles(90.,180.,-90.);
2980 mountingblockcombitrans->SetRotation(*mountingblockrot);
2981 /////////////////////////////////////////////////////////////
2982 // Generating the Mounting Block Screw Vertices
2983 /////////////////////////////////////////////////////////////
2984 const Int_t kscrewvertexnumber = 15;
2985 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
2986 - fgkSSDMountingBlockScrewHoleEdge)
2987 / fgkSSDMountingBlockScrewHoleRadius[0])
2988 * TMath::RadToDeg();
2989 Double_t phi0 = 90.+alpha;
2990 Double_t phi = 270.-2*alpha;
2991 Double_t deltaphi = phi/kscrewvertexnumber;
2992 TVector3* screwvertex[kscrewvertexnumber+1];
2993 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
2994 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
2995 *CosD(phi0+i*deltaphi),
2996 fgkSSDMountingBlockScrewHoleRadius[0]
2997 *SinD(phi0+i*deltaphi));
2998 Double_t xscrewvertex[kscrewvertexnumber+6];
2999 Double_t yscrewvertex[kscrewvertexnumber+6];
3000 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
3001 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
3002 - fgkSSDMountingBlockScrewHoleEdge);
3003 xscrewvertex[1] = xscrewvertex[0];
3004 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3005 xscrewvertex[2] = screwvertex[0]->X();
3006 yscrewvertex[2] = yscrewvertex[1];
3007 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
3008 xscrewvertex[i+3] = screwvertex[i]->X();
3009 yscrewvertex[i+3] = screwvertex[i]->Y();
3010 }
3011 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3012 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
3013 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
3014 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
3015 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
3016 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
3017 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
3018 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
3019 + fgkSSDMountingBlockHeight[2]);
3020 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
3021 ssdmountingblockscrewshape,
3022 fSSDMountingBlockMedium);
3023 ssdmountingblockscrew->SetLineColor(fColorG10);
3024 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
3025 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
3026 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3027 - yscrewvertex[1],
3028 0.5*fgkSSDMountingBlockHeight[0]
3029 - fgkSSDMountingBlockHeight[2]
3030 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3031 + fgkSSDMountingBlockHeight[2]
3032 - yvertex[0]));
3033 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3034 -0.5*fgkSSDMountingBlockScrewHoleEdge,
3035 yscrewvertex[1]
3036 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3037 +fgkSSDMountingBlockHeight[2]
3038 -yvertex[0]));
3039 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3040 yscrewvertex[1],
3041 - 0.5*fgkSSDMountingBlockHeight[0]
3042 + fgkSSDMountingBlockHeight[2]
3043 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3044 + fgkSSDMountingBlockHeight[2]
3045 - yvertex[0]));
3046 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3047 yscrewvertex[1],
3048 - yscrewvertex[1]
3049 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3050 + fgkSSDMountingBlockHeight[2]
3051 - yvertex[0]));
3052 TGeoRotation* ssdmountingblockscrewrot[4];
3053 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3054 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3055 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3056 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3057 for(Int_t i=1; i<4; i++)
3058 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3059 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3060 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3061 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3062 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3063 + xvertex[0],yscrewvertex[1]
3064 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3065 + fgkSSDMountingBlockHeight[2]
3066 - yvertex[0]),0.);
3067 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3068 for(Int_t i=0; i<4; i++){
3069 ssdmountingblockscrewmatrix[i] =
3070 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3071 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3072 }
3073 ///////////////////////////////////////////////////////////////////////
3074 // TGeoXtru for Mother Volume
3075 ///////////////////////////////////////////////////////////////////////
3076 const Int_t kvertexmothernumber = 12;
3077 Double_t xmothervertex[kvertexmothernumber];
3078 Double_t ymothervertex[kvertexmothernumber];
3079 for(Int_t i=0; i<6; i++){
3080 xmothervertex[i] = xvertex[i];
3081 ymothervertex[i] = yvertex[i];
3082 }
3083 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3084 ymothervertex[6] = ymothervertex[5];
3085 xmothervertex[7] = xmothervertex[6];
3086 ymothervertex[7] = ymothervertex[4];
3087 xmothervertex[8] = xmothervertex[7]
3088 + 0.5*(fgkSSDMountingBlockLength[1]
3089 - fgkSSDMountingBlockLength[2]);
3090 ymothervertex[8] = ymothervertex[4];
3091 xmothervertex[9] = xmothervertex[8];
3092 ymothervertex[9] = ymothervertex[2];
3093 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3094 ymothervertex[10] = ymothervertex[1];
3095 xmothervertex[11] = xmothervertex[10];
3096 ymothervertex[11] = ymothervertex[0];
3097 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3098 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3099 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3100 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3101 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3102 ssdmountingblockmothershape,
3103 fSSDAir);
3104 /////////////////////////////////////////////////////////////
3105 // Placing the Volumes into Mother Volume
3106 /////////////////////////////////////////////////////////////
3107 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3108 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3109 for(Int_t i=0; i<4; i++)
3110 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3111 ssdmountingblockscrewmatrix[i]);
3112 /////////////////////////////////////////////////////////////
3113 // Deallocating memory
3114 /////////////////////////////////////////////////////////////
3115 delete mountingblockrot;
3116 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3117 delete ssdmountingblockglobalrot;
3118 delete ssdmountingblockglobaltrans;
3119 /////////////////////////////////////////////////////////////
3120 return ssdmountingblockmother;
3121}
3122///////////////////////////////////////////////////////////////////////////////
3123 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3124 /////////////////////////////////////////////////////////////
3125 // Method generating the Mounting Block Clip
3126 /////////////////////////////////////////////////////////////
3127 const Int_t kmothervertexnumber = 10;
3128 Double_t xmothervertex[kmothervertexnumber];
3129 Double_t ymothervertex[kmothervertexnumber];
3130 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3131 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3132 xmothervertex[1] = xmothervertex[0];
3133 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3134 - fgkMountingBlockClibScrewRadius);
3135 xmothervertex[3] = xmothervertex[2];
3136 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3137 xmothervertex[5] = xmothervertex[4];
3138 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3139 xmothervertex[7] = xmothervertex[6];
3140 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3141 xmothervertex[9] = xmothervertex[8];
3142 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 3143 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 3144 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3145 ymothervertex[2] = ymothervertex[1];
3146 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3147 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3148 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3149 ymothervertex[4] = ymothervertex[3];
3150 ymothervertex[5] = ymothervertex[2];
3151 ymothervertex[6] = ymothervertex[5];
3152 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3153 ymothervertex[8] = ymothervertex[7];
3154 ymothervertex[9] = ymothervertex[0];
160835d5 3155
9b0c60ab 3156 ///////////////////////////////////////////////////////////////////////
3157 // TGeoXTru Volume definition for Mounting Block Clip Part
3158 ///////////////////////////////////////////////////////////////////////
3159 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3160 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3161 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3162 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3163 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3164 ssdmountingblockclipshape,fSSDAir);
3165 ssdmountingblockclip->SetLineColor(4);
3166 ///////////////////////////////////////////////////////////////////////
3167 // TGeoXTru Volume definition for Clip
3168 ///////////////////////////////////////////////////////////////////////
3169 const Int_t kclipvertexnumber = 6;
3170 Double_t xclipvertex[kclipvertexnumber];
3171 Double_t yclipvertex[kclipvertexnumber];
3172 xclipvertex[0] = xmothervertex[0];
3173 xclipvertex[1] = xclipvertex[0];
3174 xclipvertex[2] = xmothervertex[6];
3175 xclipvertex[3] = xclipvertex[2];
3176 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3177 xclipvertex[5] = xclipvertex[4];
3178 yclipvertex[0] = ymothervertex[0];
3179 yclipvertex[1] = ymothervertex[1];
3180 yclipvertex[2] = yclipvertex[1];
3181 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3182 yclipvertex[4] = yclipvertex[3];
3183 yclipvertex[5] = yclipvertex[0];
3184 TGeoXtru* clipshape = new TGeoXtru(2);
3185 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3186 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3187 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3188 + fgkMountingBlockClibWidth);
3189 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3190 clip->SetLineColor(18);
3191 ///////////////////////////////////////////////////////////////////////
3192 // Ladder Support Piece
3193 ///////////////////////////////////////////////////////////////////////
3194 const Int_t ksupportvertexnumber = 4;
3195 Double_t xsupportvertex[ksupportvertexnumber];
3196 Double_t ysupportvertex[ksupportvertexnumber];
3197 xsupportvertex[0] = xclipvertex[5];
3198 xsupportvertex[1] = xsupportvertex[0];
3199 xsupportvertex[2] = xmothervertex[9];
3200 xsupportvertex[3] = xsupportvertex[2];
3201 ysupportvertex[0] = yclipvertex[0];
3202 ysupportvertex[1] = yclipvertex[3];
3203 ysupportvertex[2] = ysupportvertex[1];
3204 ysupportvertex[3] = ysupportvertex[0];
3205 TGeoXtru* supportshape = new TGeoXtru(2);
3206 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3207 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3208 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3209 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3210 support->SetLineColor(9);
3211 ///////////////////////////////////////////////////////////////////////
3212 // TGeoXTru Volume definition for Screw
3213 ///////////////////////////////////////////////////////////////////////
3214 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3215 0.5*fgkMountingBlockClibScrewRadius};
3216 Int_t edgesnumber[2] = {50,6};
3217 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3218 +0.5*(ymothervertex[3]-ymothervertex[2])};
851c0ce3 3219 TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
9b0c60ab 3220 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3221 clipscrew->SetLineColor(12);
3222 TGeoRotation* screwrot = new TGeoRotation();
3223 screwrot->SetAngles(0.,90.,0.);
3224 TGeoTranslation* screwtrans = new TGeoTranslation();
3225 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3226 0.5*(ymothervertex[3]+ymothervertex[2]),
3227 0.5*fgkSSDMountingBlockWidth+
3228 -0.5*fgkMountingBlockSupportWidth[0]);
3229 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3230 ///////////////////////////////////////////////////////////////////////
3231 // Placing the Volumes
3232 ///////////////////////////////////////////////////////////////////////
3233 ssdmountingblockclip->AddNode(clip,1);
3234 ssdmountingblockclip->AddNode(support,1);
3235 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3236 /////////////////////////////////////////////////////////////
3237 // Deallocating memory
3238 /////////////////////////////////////////////////////////////
3239 delete screwtrans;
3240 delete screwrot;
3241 /////////////////////////////////////////////////////////////
3242 return ssdmountingblockclip;
d7599219 3243}
bf210566 3244///////////////////////////////////////////////////////////////////////////////
cd2243fb 3245void AliITSv11GeometrySSD::CreateCoolingTubes() {
44285dfa 3246 /////////////////////////////////////////////////////////////
bf210566 3247 // Method generating the Cooling Tube
cd2243fb 3248 // sets fcoolingtube and returns list for endladdercoolingtube
44285dfa 3249 /////////////////////////////////////////////////////////////
cd2243fb 3250 TGeoTube *coolingtubeshape[2];
3251 // Ladder Cooling Tubes
3252
3253 // MvL: Simplified cooling tubes
3254 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
3255 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
3256
3257 // End Ladder Cooling Tubes
3258 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3259 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3260 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3261
3262 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
3263 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3264 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
3265 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3266 endladdercoolingtubeshape[0][0]->GetDz());
3267 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3268 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
3269 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3270 endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
3271 // Ladder Cooling Tubes
3272 TGeoVolume* coolingtube[2];
3273 coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
3274 coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
3275 coolingtube[0]->SetLineColor(fColorPhynox);
3276 coolingtube[1]->SetLineColor(fColorWater);
3277
3278 // End Ladder Cooling Tubes
3279 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3280 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3281 endladdercoolingtube[i] = new TGeoVolume*[2];
3282 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3283 endladdercoolingtubeshape[0][0],
3284 fSSDCoolingTubePhynox);
3285 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3286 endladdercoolingtubeshape[0][1],
3287 fSSDCoolingTubeWater);
3288 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3289 endladdercoolingtubeshape[1][0],
3290 fSSDCoolingTubePhynox);
3291 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3292 endladdercoolingtubeshape[1][1],
3293 fSSDCoolingTubeWater);
3294 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3295 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3296 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3297 }
0fb26117 3298
bf210566 3299 /////////////////////////////////////////////////////////////
3300 // Virtual Volume containing Cooling Tubes
3301 /////////////////////////////////////////////////////////////
9b0c60ab 3302 // Ladder Cooling Tubes
cd2243fb 3303 TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
3304 coolingtubeshape[0]->GetRmax(),
3305 coolingtubeshape[0]->GetDz());
3306 fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
3307 fcoolingtube->AddNode(coolingtube[0],1);
3308 fcoolingtube->AddNode(coolingtube[1],1);
3309
9b0c60ab 3310 // End Ladder Cooling Tubes
3311 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3312 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
cd2243fb 3313 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3314 endladdercoolingtubeshape[i][0]->GetRmax(),
3315 endladdercoolingtubeshape[i][0]->GetDz());
3316 fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3317 endladdervirtualcoolingtubeshape[0],
3318 fSSDAir);
3319 fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3320 endladdervirtualcoolingtubeshape[1],
3321 fSSDAir);
3322 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3323 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3324 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3325 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
d7599219 3326}
bf210566 3327///////////////////////////////////////////////////////////////////////////////
3328TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3329 /////////////////////////////////////////////////////////////
bf210566 3330 // Method generating SSD Cooling Block
44285dfa 3331 /////////////////////////////////////////////////////////////
bf210566 3332 const Int_t kvertexnumber = 8;
3333 ///////////////////////////////////////
3334 // Vertex Positioning for TGeoXTru
3335 ///////////////////////////////////////
3336 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3337 vertexposition[0] = new TVector3(0.0,0.0);
3338 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3339 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3340 vertexposition[1]->Y());
3341 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3342 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3343 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3344 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3345 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3346 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3347 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3348 - fgkSSDCoolingBlockHoleLength[0]
3349 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3350 fgkSSDCoolingBlockHeight[0]
3351 - fgkSSDCoolingBlockHoleRadius[1],
3352 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3353 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3354 - fgkSSDCoolingBlockHoleLength[0]),
3355 vertexposition[6]->Y());
3356 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3357 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3358 Double_t phi = 180.-alpha;
3359 Double_t psi = 180.+2.*alpha;
3360 Double_t deltapsi = psi/nedges;
3361 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3362 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3363 fgkSSDCoolingBlockHoleCenter);
3364 for(Int_t i=0; i<nedges+1; i++){
3365 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3366 radius*SinD(phi+i*deltapsi));
3367 *vertexposition[kvertexnumber+i] += (*transvector);
3368 }
3369 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3370 for(Int_t i=0; i<kvertexnumber; i++)
3371 vertexposition[kvertexnumber+nedges+1+i] =
3372 GetReflection(vertexposition[kvertexnumber-1-i],param);
3373 ///////////////////////////////////////////////////////////////////////
3374 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3375 ///////////////////////////////////////////////////////////////////////
3376 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3377 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3378 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3379 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3380 xvertexpoints[i] = vertexposition[i]->X();
3381 yvertexpoints[i] = vertexposition[i]->Y();
3382 }
3383 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3384 yvertexpoints);
3385 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3386 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3387 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3388 ssdcoolingblockshape,
3389 fSSDAlCoolBlockMedium);
3390 ssdcoolingblock->SetLineColor(fColorAl);
3391 /////////////////////////////////////////////////////////////
3392 // Deallocating memory
3393 /////////////////////////////////////////////////////////////
3394 delete [] vertexposition;
7b208ef4 3395 delete [] xvertexpoints;
3396 delete [] yvertexpoints;
bf210566 3397 /////////////////////////////////////////////////////////////
3398 return ssdcoolingblock;
3399}
3400/////////////////////////////////////////////////////////////////////////////////
3cf6a656 3401void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
d7599219 3402 ///////////////////////////////////////////////////////
cd2243fb 3403 static const Int_t kssdchipcablesnumber = 2; // Number of cables: left and right
3404 static const Int_t kssdchipcableslaynumber = 2; // Number of layers: Al and Kapton
3405 static const Int_t kvertexnumber = 4*(nedges+1)+4;
bf210566 3406 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3407 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
cd2243fb 3408 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
bf210566 3409 - fgkSSDChipCablesHeight[0]
3410 - fgkSSDChipCablesHeight[1]);
3411 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3412 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3413 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3414 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3415 - ssdchipcablesradius[0]
3416 - fgkSSDChipCablesWidth[1]
3417 - fgkSSDChipCablesWidth[2]);
3418 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3419 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3420 + fgkSSDChipCablesHeight[1]
3421 + fgkSSDSensorHeight);
d7599219 3422 ///////////////////////////////////////////////////////
bf210566 3423 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3424 ///////////////////////////////////////////////////////
3425 TVector3** vertexposition[kssdchipcableslaynumber];
3426 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3427 new TVector3*[4*(nedges+1)+4];
3428 Double_t ratio[4];
3429 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3430 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3431 / ssdchipcablesradius[0];
3432 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3433 / ssdchipcablesradius[0];
3434 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3435 + fgkSSDChipCablesHeight[1])
3436 / ssdchipcablesradius[0];
3437 Double_t phi = 180.;
3438 Double_t deltaphi = 180./nedges;
3439 Double_t angle = 0.0;
045be90c 3440
3441 Double_t xvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3442 Double_t yvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3443
bf210566 3444 TVector3* vertex = new TVector3();
3445 TVector3* transvector[kssdchipcableslaynumber];
3446 transvector[0] = new TVector3(fgkSSDChipWidth,
cd2243fb 3447 SSDChipCablesHeight-ssdchipcablesradius[0]);
bf210566 3448 transvector[1] = new TVector3();
cd2243fb 3449 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
3450 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
3451 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
bf210566 3452 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3453 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3454 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3455 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3456 transvector[1]->SetY(ssdchipcablesradius[0]
3457 + fgkSSDChipCablesHeight[0]
3458 + fgkSSDChipCablesHeight[1]);
3459 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
cd2243fb 3460 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
bf210566 3461 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
cd2243fb 3462 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
bf210566 3463 - i*fgkSSDChipCablesHeight[0]);
3464 vertexposition[i][2*(nedges+1)+2] =
3465 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3466 + fgkSSDChipCablesWidth[1]
3467 + fgkSSDChipCablesWidth[2],
3468 ((1.-i)*fgkSSDChipCablesHeight[i]
3469 + fgkSSDChipCablesHeight[1]));
3470 vertexposition[i][2*(nedges+1)+3] =
3471 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3472 vertexposition[i][2*(nedges+1)+2]->Y()
3473 - fgkSSDChipCablesHeight[i]);
3474 for(Int_t j=0; j<nedges+1; j++){
3475 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3476 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3477 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3478 vertexposition[0][(nedges+1)*i+j+2] =
3479 new TVector3(*vertex+*transvector[i]);
3480 vertexposition[1][(nedges+1)*i+j+2] =
3481 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3482 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3483 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3484 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3485 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3486 new TVector3(vertex->X()*ratio[2*i+1]
3487 + transvector[i]->X(),
3488 vertex->Y()*ratio[2*i+1]
3489 + transvector[i]->Y());
3490 }
3491 }
3492 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3493 for(Int_t j=0; j<kvertexnumber; j++){
3494 xvertexpoints[i][j] = vertexposition[i][j]->X();
3495 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3496 }
3497 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3498 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3499 xvertexpoints[i],yvertexpoints[i]);
3500 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3501 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3502 ssdchipcable[kssdchipcablesnumber*k+i] =
3503 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3504 ssdchipcableshape[kssdchipcablesnumber*k+i],
3505 (kssdchipcablesnumber*k+i)%2==0?
3506 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3507 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3508 }
3509 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3510 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3511 }
44285dfa 3512 /////////////////////////////////////////////////////////////
bf210566 3513 // Mother Volume definition
3514 /////////////////////////////////////////////////////////////
cd2243fb 3515 static const Int_t kmothervertexnumber = 8;
3516 Double_t xmothervertex[kmothervertexnumber];
3517 Double_t ymothervertex[kmothervertexnumber];
3518 xmothervertex[0] = xvertexpoints[0][1];
3519 ymothervertex[0] = yvertexpoints[0][1];
3520 xmothervertex[1] = xvertexpoints[0][2+nedges/2];
3521 ymothervertex[1] = yvertexpoints[0][1];
3522 xmothervertex[2] = xvertexpoints[0][2+nedges/2];
3523 ymothervertex[2] = yvertexpoints[0][2+nedges];
3524 xmothervertex[3] = xvertexpoints[0][3+nedges];
3525 ymothervertex[3] = yvertexpoints[0][3+nedges];
3526 xmothervertex[4] = xvertexpoints[0][3+2*nedges];
3527 ymothervertex[4] = yvertexpoints[0][3+2*nedges];
3528 xmothervertex[5] = xvertexpoints[0][4+2*nedges];
3529 ymothervertex[5] = yvertexpoints[0][4+2*nedges];
3530 xmothervertex[6] = xvertexpoints[1][5+2*nedges];
3531 ymothervertex[6] = yvertexpoints[1][5+2*nedges];
3532 xmothervertex[7] = xvertexpoints[0][1];
3533 ymothervertex[7] = yvertexpoints[1][5+2*nedges];
3534 TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
3535 ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3536 ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3537 ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3538
3cf6a656 3539 cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
3540 cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
cd2243fb 3541
3cf6a656 3542 cableL->AddNode(ssdchipcable[0],1);
3543 cableL->AddNode(ssdchipcable[1],1);
3544 cableR->AddNode(ssdchipcable[2],1);
3545 cableR->AddNode(ssdchipcable[3],1);
cd2243fb 3546
bf210566 3547 /////////////////////////////////////////////////////////////
3548 // Deallocating memory
3549 /////////////////////////////////////////////////////////////
bf210566 3550 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3551 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3552 delete vertex;
bf210566 3553 /////////////////////////////////////////////////////////////
d7599219 3554}
5bf92139 3555//_____________________________________________________________________________
3cf6a656 3556TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
44285dfa 3557 /////////////////////////////////////////////////////////////
bf210566 3558 // SSD Chip Assembly Generation
3559 /////////////////////////////////////////////////////////////
bf210566 3560 TGeoBBox* ssdchipcompshape[2];
3561 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3562 0.5*fgkSSDChipLength,
3563 0.5*fgkSSDChipWidth,
3564 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3565 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3566 0.5*fgkSSDChipLength,
3567 0.5*fgkSSDChipWidth,
3568 0.5*fgkSSDChipGlueHeight);
3569 TGeoVolume* ssdchipcomp[2];
3570 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3571 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3572 fSSDChipGlueMedium);
3573 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3574 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3575 TGeoTranslation* ssdchipcomptrans[2];
3576 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3577 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3578 /////////////////////////////////////////////////////////////
3579 // Virtual Volume containing SSDChip
3580 /////////////////////////////////////////////////////////////
3581 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3582 0.5*fgkSSDChipWidth,
3583 0.5*fgkSSDChipHeight);
e21cdd03 3584 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
bf210566 3585 /////////////////////////////////////////////////////////////
3586 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3cf6a656 3587 return ssdchip;
d7599219 3588}
bf210566 3589/////////////////////////////////////////////////////////////////////////////////
3590TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3591 /////////////////////////////////////////////////////////////
bf210566 3592 // Method returning a List containing pointers to Ladder Cable Volumes
cd2243fb 3593 //
3594 // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
3595 // each contains 2 volumes, one for polyamide and one for aluminium
44285dfa 3596 /////////////////////////////////////////////////////////////
bf210566 3597 const Int_t kladdercablesegmentnumber = 2;
3598 /////////////////////////////////////////
3599 // LadderSegmentBBox Volume
3600 /////////////////////////////////////////
160835d5 3601 static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
bf210566 3602 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3603 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
160835d5 3604
3605
3606 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3607 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3608 static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3609
3610 static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
3611 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3612 0.5*fgkSSDFlexWidth[0],
3613 0.5*fgkSSDLadderCableWidth,
78e34526 3614 0.5*fgkSSDLadderCableHeight[0]),
160835d5 3615 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3616 0.5*fgkSSDFlexWidth[0],
3617 0.5*fgkSSDLadderCableWidth,
78e34526 3618 fgkSSDLadderCableHeight[0]
3619 +0.5*fgkSSDLadderCableHeight[1])
160835d5 3620 };
3621 static TGeoVolume* laddercablesegmentbboxassembly = new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
3622 static TGeoVolume* laddercablesegmentarbassembly =
3623 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3624
3625 static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3626 static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3627
3628 if (laddercablesegmentbboxshape[0] == 0) {
3629 // Initialise static shapes and volumes
bf210566 3630 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3631 new TGeoBBox(laddercablesegmentbboxshapename[i],
3632 0.5*fgkSSDFlexWidth[0],
3633 0.5*fgkSSDLadderCableWidth,
78e34526 3634 0.5*fgkSSDLadderCableHeight[i]);
160835d5 3635
bf210566 3636 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3637 laddercablesegmentbbox[i] =
3638 new TGeoVolume(laddercablesegmentbboxname[i],
3639 laddercablesegmentbboxshape[i],
3640 (i==0?fSSDAlTraceLadderCableMedium:
3641 fSSDKaptonLadderCableMedium));
3642 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3643 fColorPolyhamide);
3644 }
160835d5 3645
bf210566 3646 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3647 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3648 laddercablesegmentbboxtrans[i]);
3649/////////////////////////////////////////
3650// LadderSegmentArb8 Volume
3651/////////////////////////////////////////
3652 const Int_t kvertexnumber = 4;
3653 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3654 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3655 new TVector3*[kvertexnumber];
3656//Shape Vertex Positioning
3657 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3658 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3659 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3660 i*fgkSSDFlexHeight[0]);
3661 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3662 + fgkSSDFlexHeight[1]
3663 + i*fgkSSDFlexHeight[0]);
3664 laddercablesegmentvertexposition[i][3] =
3665 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3666 laddercablesegmentvertexposition[i][2]->Y());
3667 }
3668 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3669 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
a6e0ebfe 3670 const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
bf210566 3671 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
160835d5 3672
bf210566 3673 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3674 GetArbShape(laddercablesegmentvertexposition[i],
3675 laddercablesegmentwidth[i],
3676 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3677 laddercablesegmentarbshapename[i]);
3678 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3679 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
160835d5 3680
bf210566 3681 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3682 laddercablesegmentarb[i] =
3683 new TGeoVolume(laddercablesegmentarbname[i],
3684 laddercablesegmentarbshape[i],
3685 (i==0?fSSDAlTraceLadderCableMedium:
3686 fSSDKaptonLadderCableMedium));
3687 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3688 fColorPolyhamide);
d7599219 3689}
bf210566 3690 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3691 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3692 90.,90,-90.);
3693 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3694 0.,90.,0.);
3695 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3696 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3697 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3698 + fgkSSDFlexWidth[0],0.,0.,
3699 new TGeoRotation((*laddercablesegmentarbrot[1])
3700 *(*laddercablesegmentarbrot[0])));
bf210566 3701 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3702 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3703 laddercablesegmentarbcombitrans);
160835d5 3704 } // End of static initialisations
bf210566 3705/////////////////////////////////////////
3706// End Ladder Cable Volume
160835d5 3707// Note: this part depends explicitly on the length passed as an argument to the function
bf210566 3708/////////////////////////////////////////
3709 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3710 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3711 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3712 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3713 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3714 0.5*ssdendladdercablelength,
3715 0.5*fgkSSDLadderCableWidth,
78e34526 3716 0.5*fgkSSDLadderCableHeight[i]);
bf210566 3717 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3718 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3719 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3720 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3721 ladderendcablesegmentbbox[i] =
3722 new TGeoVolume(ladderendcablesegmentbboxname[i],
3723 ladderendcablesegmentbboxshape[i],
3724 (i==0?fSSDAlTraceLadderCableMedium:
3725 fSSDKaptonLadderCableMedium));
3726 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3727 fColorPolyhamide);
3728 }
3729 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3730 ladderendcablesegmentbboxtrans[0] =
3731 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
3732 0.5*ssdendladdercablelength,
3733 0.5*fgkSSDLadderCableWidth,
78e34526 3734 0.5*fgkSSDLadderCableHeight[0]);
bf210566 3735 ladderendcablesegmentbboxtrans[1] =
3736 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
3737 0.5*ssdendladdercablelength,
3738 0.5*fgkSSDLadderCableWidth,
78e34526 3739 fgkSSDLadderCableHeight[0]
3740 +0.5*fgkSSDLadderCableHeight[1]);
bf210566 3741 TGeoVolume* ladderendcablesegmentbboxassembly =
3742 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
3743 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3744 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
3745 ladderendcablesegmentbboxtrans[i]);
3746/////////////////////////////////////////
3747 TList* laddercablesegmentlist = new TList();
3748 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
3749 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
3750 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
3751 return laddercablesegmentlist;
160835d5 3752}
3753
bf210566 3754/////////////////////////////////////////////////////////////////////////////////
3755TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 3756 /////////////////////////////////////////////////////////////
cd2243fb 3757 // Method generating Ladder Cable of given length (n modules + end)
3758 // Called by GetLadderCableAssembly
44285dfa 3759 /////////////////////////////////////////////////////////////
bf210566 3760 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
3761 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
3762 for(Int_t i=0; i<n; i++){
3763 TGeoTranslation* laddercabletrans = new TGeoTranslation(
3764 i*(fgkCarbonFiberJunctionWidth),
3765 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
78e34526 3766 i*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
bf210566 3767 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
cd2243fb 3768 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
3769
d7599219 3770 }
bf210566 3771 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
3772 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
cd2243fb 3773 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
78e34526 3774 (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
bf210566 3775 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
3776 return laddercable;
3777}
3778/////////////////////////////////////////////////////////////////////////////////
3779TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
cd2243fb 3780 ///////////////////////////////////////////////////////////////////
3781 // Main method generating Ladder Cable bundles containing n cables
3782 ///////////////////////////////////////////////////////////////////
3783 Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
78e34526 3784 Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])};
3785 TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]),cableOrig);
cd2243fb 3786 TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
a3f8715e 3787 char laddercabletransname[100];
bf210566 3788 for(Int_t i=0; i<n; i++){
045be90c 3789 snprintf(laddercabletransname,100,"LadderCableTrans%i",i+1);
3790 laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
3791 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
d7599219 3792 }
cd2243fb 3793 return laddercable;
bf210566 3794}
3795/////////////////////////////////////////////////////////////////////////////////
3796TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
3797 /////////////////////////////////////////////////////////////
3798 // Method generating Ladder Cable List Assemblies
cd2243fb 3799 // containing two cables bundles, i.e. P+N readout for one endcap
bf210566 3800 /////////////////////////////////////////////////////////////
cd2243fb 3801 const Int_t kladdercableassemblynumber = 2;
bf210566 3802 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
3803 TGeoVolume* ladderCable[kladdercableassemblynumber];
a3f8715e 3804 char laddercableassemblyname[100];
bf210566 3805 TList* laddercableassemblylist = new TList();
3806 for(Int_t i=0; i<kladdercableassemblynumber; i++){
045be90c 3807 snprintf(laddercableassemblyname,100,"LadderCableAssembly%i",i+1);
bf210566 3808 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
3809 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
3810 new TGeoCombiTrans((n-1)
3811 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3812 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
3813 0.,new TGeoRotation("",180,0.,0.)));
3814 laddercableassemblylist->Add(ladderCable[i]);
3815}
3816 return laddercableassemblylist;
3817}
3818///////////////////////////////////////////////////////////////////////////////
3819void AliITSv11GeometrySSD::SetLadderSegment(){
3820 /////////////////////////////////////////////////////////////
3821 // Method Generating Ladder Segment Array
3822 /////////////////////////////////////////////////////////////
3823 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
3824 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
cd2243fb 3825
3826 /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
3827 TGeoXtru *laddersegmentshape = new TGeoXtru(2);
3828 static const Int_t ntrianglevtx = 3;
3829 Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
3830 Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
3831 laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
3832 laddersegmentshape->DefineSection(0,0);
3833 laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth); // MVL
3834 fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
3835 fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
3836 */
3837
bf210566 3838 if(!fCreateMaterials) CreateMaterials();
3839 if(!fTransformationMatrices) CreateTransformationMatrices();
3840 if(!fBasicObjects) CreateBasicObjects();
3841 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
3842 // Placing Carbon Fiber Support
3843 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
3844 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3845 fcarbonfibersupportmatrix[j]);
3846 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3847 fcarbonfibersupportmatrix[j]);
d7599219 3848 }
bf210566 3849 // Placing Carbon Fiber Junction
cd2243fb 3850 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
bf210566 3851 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
3852 fcarbonfiberjunctionmatrix[j]);
cd2243fb 3853 }
bf210566 3854 // Placing Carbon Fiber Lower Support
cd2243fb 3855 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
bf210566 3856 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
3857 fcarbonfiberlowersupportrans[j]);
cd2243fb 3858 }
bf210566 3859 // Placing SSD Sensor Support
3860 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
cd2243fb 3861 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
bf210566 3862 fssdsensorsupport[1][i],
3863 j+1,fssdsensorsupportmatrix[j]);
3864 // Placing SSD Cooling Tube Support
3865 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
3866 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3867 fcoolingtubesupportmatrix[j]);
3868 // Placing SSD Cooling Tube
cd2243fb 3869 fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
3870 fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
bf210566 3871 // Placing SSD Hybrid
3872 switch(i){
3873 case 0:
3874 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
3875 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3876 break;
3877 case 1:
3878 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
3879 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3880 break;
3881 }
3882 // Placing Cooling Block System
cd2243fb 3883 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
bf210566 3884 // Placing SSD Flex
cd2243fb 3885 for(Int_t j=0; j<fgkflexnumber; j++){
3886 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
3887 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
3888 }
bf210566 3889 }
d7599219 3890}
bf210566 3891///////////////////////////////////////////////////////////////////////////////
3892void AliITSv11GeometrySSD::SetEndLadderSegment(){
3893 /////////////////////////////////////////////////////////////
3894 // Method Generating End Ladder
3895 /////////////////////////////////////////////////////////////
3896 // End Ladder Carbon Fiber Junction
3897 /////////////////////////////////////////////////////////////
3898 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
3899 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
3900 if(!fCreateMaterials) CreateMaterials();
3901 if(!fTransformationMatrices) CreateTransformationMatrices();
3902 if(!fBasicObjects) CreateBasicObjects();
3903 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
3904 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
3905 fendladdersegment[i]->AddNode(j==2 ?
3906 fendladdercarbonfiberjunction[i][1] :
3907 fendladdercarbonfiberjunction[i][0],
3908 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
3909 }
3910 /////////////////////////////////////////////////////////////
3911 // End Ladder Carbon Fiber Support
3912 /////////////////////////////////////////////////////////////
3913 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
3914 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
3915 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3916 fendladdercarbonfibermatrix[i][j]);
3917 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3918 fendladdercarbonfibermatrix[i][j]);
3919 }
3920 /////////////////////////////////////////////////////////////
3921 // End Ladder Mounting Block
3922 /////////////////////////////////////////////////////////////
9b0c60ab 3923 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3924 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
e21cdd03 3925 fendladdermountingblockcombitrans[i]);
9b0c60ab 3926 /////////////////////////////////////////////////////////////
e5bf64ae 3927 // End Ladder Mounting Block Clip
9b0c60ab 3928 /////////////////////////////////////////////////////////////
3929 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3930 for(Int_t j=0; j<2; j++)
e21cdd03 3931 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
3932 fendladdermountingblockclipmatrix[i][j]);
bf210566 3933 /////////////////////////////////////////////////////////////
3934 // End Ladder Lower Supports
44285dfa 3935 /////////////////////////////////////////////////////////////
bf210566 3936 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
e21cdd03 3937 fendladderlowersupptrans[0]);
bf210566 3938 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
e21cdd03 3939 fendladderlowersupptrans[1]);
bf210566 3940 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
e21cdd03 3941 fendladderlowersupptrans[2]);
9b0c60ab 3942 /////////////////////////////////////////////////////////////
3943 // End Ladder Cooling Tube Support
3944 /////////////////////////////////////////////////////////////
3945 for(Int_t i=0; i<2; i++)
3946 for(Int_t j=0; j<(i==0?4:2); j++)
e21cdd03 3947 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3948 fendladdercoolingtubesupportmatrix[i][j]);
9b0c60ab 3949 /////////////////////////////////////////////////////////////
3950 // End Ladder Cooling Tube Support
3951 /////////////////////////////////////////////////////////////
cd2243fb 3952 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
3953 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
3954 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
3955 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
bf210566 3956}
3957///////////////////////////////////////////////////////////////////////////////
3958void AliITSv11GeometrySSD::SetLadder(){
3959 /////////////////////////////////////////////////////////////
3960 // Method Generating Ladder of Layer 5 and 6
44285dfa 3961 /////////////////////////////////////////////////////////////
bf210566 3962 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
3963 fgkSSDLay6SensorsNumber};
3964 /////////////////////////////////////////////////////////////////////////////
3965 /// Generating Ladder Mother Volume Containing Ladder
3966 /////////////////////////////////////////////////////////////////////////////
3967 TGeoXtru* laddershape[fgkladdernumber];
3968 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
3969 const Int_t kmothervertexnumber = 8;
3970 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
3971 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
3972 ///////////////////////
3973 // Setting the vertices
3974 ///////////////////////
3975 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
78e34526 3976 * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]);
bf210566 3977 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
0fb26117 3978 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
bf210566 3979 xmothervertex[0][1] = xmothervertex[0][0];
78e34526 3980 ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010
bf210566 3981 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
3982 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
3983 ymothervertex[0][2] = ymothervertex[0][1];
3984 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
3985 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
3986 xmothervertex[0][4] = -xmothervertex[0][3];
3987 ymothervertex[0][4] = ymothervertex[0][3];
3988 xmothervertex[0][5] = -xmothervertex[0][2];
3989 ymothervertex[0][5] = ymothervertex[0][2];
3990 xmothervertex[0][6] = -xmothervertex[0][1];
3991 ymothervertex[0][6] = ymothervertex[0][1];
3992 xmothervertex[0][7] = -xmothervertex[0][0];
3993 ymothervertex[0][7] = ymothervertex[0][0];
3994 for(Int_t i=0; i<kmothervertexnumber; i++){
3995 xmothervertex[1][i] = xmothervertex[0][i];
3996 ymothervertex[1][i] = ymothervertex[0][i];
3997 }
0fb26117 3998///////////////////////////////////////////////////////////////////////////
3999// Disalignement Mother Volume corrections 25/08/08
4000///////////////////////////////////////////////////////////////////////////
160835d5 4001 TGeoXtru* leftladdershape1[fgkladdernumber];
4002 TGeoXtru* leftladdershape2[fgkladdernumber];
0fb26117 4003 TGeoXtru* centersensorladdershape[fgkladdernumber];
160835d5 4004 TGeoXtru* rightladdershape1[fgkladdernumber];
4005 TGeoXtru* rightladdershape2[fgkladdernumber];
bf210566 4006 for(Int_t i=0; i<fgkladdernumber; i++){
160835d5 4007 leftladdershape1[i] = new TGeoXtru(2);
4008 leftladdershape2[i] = new TGeoXtru(2);
4009 centersensorladdershape[i] = new TGeoXtru(2);
4010 rightladdershape1[i] = new TGeoXtru(2);
4011 rightladdershape2[i] = new TGeoXtru(2);
4012 }
0fb26117 4013 //////////////////////////////////////
160835d5 4014 // Setting the names for shapes
0fb26117 4015 //////////////////////////////////////
160835d5 4016 leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
4017 leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
4018 leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
4019 leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
0fb26117 4020 centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
4021 centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
160835d5 4022 rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
4023 rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
4024 rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
4025 rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
0fb26117 4026 //////////////////////////////////////
160835d5 4027 Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
4028 Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
0fb26117 4029 Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
4030 Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
160835d5 4031 Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
4032 Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
4033 for(Int_t i=0; i<fgkladdernumber; i++) {
4034 for(Int_t j=0; j<kmothervertexnumber; j++){
4035 xcentersensorvertex[i][j] = xmothervertex[i][j];
4036 ycentersensorvertex[i][j] = ymothervertex[i][j];
4037 xend1laddervertex[i][j] = xmothervertex[i][j];
4038 yend1laddervertex[i][j] = ymothervertex[i][j];
4039 xend2laddervertex[i][j] = xmothervertex[i][j];
4040 yend2laddervertex[i][j] = ymothervertex[i][j];
4041 }
4042 // Add some space around sensors to accommodate misalignments
4043 xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
4044 xcentersensorvertex[i][1] = xcentersensorvertex[0][0];
4045 xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
4046 xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
4047
4048 ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
4049 ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
4050
4051 // Center Ladder Piece
4052 centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
4053 ycentersensorvertex[i]);
4054 centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
4055 + 1.45*fgkSSDMountingBlockWidth);
4056 centersensorladdershape[i]->DefineSection(1, ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
4057 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4058 - 2.4*fgkSSDMountingBlockWidth);
0fb26117 4059
160835d5 4060 // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
0fb26117 4061
160835d5 4062 // Cuts off first corner (neg x)
4063 xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4064 xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
4065 // Cuts off last part (pos x)
4066 xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
4067 xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
0fb26117 4068
160835d5 4069 leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4070 yend1laddervertex[i]);
4071 leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4072 leftladdershape1[i]->DefineSection(1, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4073 - fgkEndLadderMountingBlockPosition[0]);
4074
4075 leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4076 yend2laddervertex[i]);
4077 leftladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4078 - fgkEndLadderMountingBlockPosition[0]);
4079 leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
4080 + 1.45*fgkSSDMountingBlockWidth); // connect to main volume at -1.6725 cm
4081
4082 rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4083 yend1laddervertex[i]);
4084 rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4085 +fgkEndLadderCarbonFiberLowerJunctionLength[0]
4086 -2.4*fgkSSDMountingBlockWidth);
4087 rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4088 + fgkEndLadderMountingBlockPosition[1]);
4089
4090 rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4091 yend2laddervertex[i]);
4092 rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4093 + fgkEndLadderMountingBlockPosition[1]);
4094 rightladdershape2[i]->DefineSection(1, ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4095 + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4096 }
4097 TGeoCompositeShape* laddershapecontainer[2];
4098 laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4099 "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4100 "+Lay5CenterSensorContainer"
4101 "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4102 laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4103 "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4104 "+Lay6CenterSensorContainer"
4105 "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4106 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4107 for(Int_t i=0; i<fgkladdernumber; i++){
4108 fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4109 fladder[i]->SetLineColor(4);
4110 }
bf210566 4111///////////////////////////////////////////////////////////////////////////
4112 if(!fCreateMaterials) CreateMaterials();
4113 if(!fTransformationMatrices) CreateTransformationMatrices();
4114 if(!fBasicObjects) CreateBasicObjects();
4115 SetLadderSegment();
4116 SetEndLadderSegment();
4117 for(Int_t i=0; i<fgkladdernumber; i++){
4118 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4119 //////////////////////////
4120 /// Placing Ladder Segment
4121 //////////////////////////
4122 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4123 fladdersegment[i==0 ? 1 : 0],
4124 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4125 //////////////////////////
4126 /// Placing SSD Sensor
4127 //////////////////////////
ca86fdb4 4128 if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
bf210566 4129 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4130 fssdsensormatrix[i][j]);
4131 }
4132 ///////////////////////////////
4133 /// Placing End Ladder Segment
4134 ///////////////////////////////
160835d5 4135 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
bf210566 4136 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4137 }
d7599219 4138/////////////////////////////////////////////////////////////////////////////
4139/// Placing Ladder Cables
4140/////////////////////////////////////////////////////////////////////////////
bf210566 4141 Int_t sidecablenumber[2][2];
4142 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4143 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4144 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4145 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4146 Double_t carbonfibertomoduleposition[3];
4147 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4148 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4149 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4150 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4151 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4152 - fgkSSDSensorCenterSupportThickness[0]);
4153 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4154 + 0.5*fgkCoolingTubeSupportHeight
4155 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4156 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4157 Double_t ssdendladdercablelength[4];
4158 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4159 + fgkSSDSensorLength
4160 - fgkSSDModuleStiffenerPosition[1]
4161 - fgkSSDStiffenerWidth
4162 - fgkSSDFlexWidth[0]
bf210566 4163 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4164 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4165 + fgkSSDModuleStiffenerPosition[1]
4166 + fgkSSDStiffenerWidth
bf210566 4167 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4168 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4169 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4170 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4171 - kendladdercablecorrection;
44285dfa 4172 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4173 + carbonfibertomoduleposition[1]
d7599219 4174 - fgkSSDModuleStiffenerPosition[1]
4175 - fgkSSDStiffenerWidth)
bf210566 4176 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
78e34526 4177
44285dfa 4178 TList* laddercableassemblylist[4];
4179 const Int_t kendladdercablesnumber = 4;
cd2243fb 4180 TGeoRotation *laddercablerot = new TGeoRotation();
4181 laddercablerot->SetAngles(90.,60.,-90.);
bf210566 4182 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4183 for(Int_t j=0; j<kendladdercablesnumber; j++){
4184 laddercableassemblylist[j] =
4185 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4186 ssdendladdercablelength[j]);
0fb26117 4187 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4188 j<2?1:2,fladdercablematrix[i][j]);
bf210566 4189 }
bf210566 4190}
4191////////////////////////////////////////////////////////////////////////////////
4192void AliITSv11GeometrySSD::SetLayer(){
d7599219 4193////////////////////////////////////////////////////////////////////////////////
bf210566 4194 // Creating Ladder of Layer 5 and Layer 6
4195 /////////////////////////////////////////////////////////////
4196 if(!fCreateMaterials) CreateMaterials();
4197 if(!fTransformationMatrices) CreateTransformationMatrices();
4198 if(!fBasicObjects) CreateBasicObjects();
4199 SetLadder(); // Generating the ladder of Layer5 and Layer6
4200 const Int_t kssdlayladdernumber[fgklayernumber] =
4201 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4202 /////////////////////////////////////////////////////////////
4203 // Generating mother volumes for Layer5 and Layer6
4204 /////////////////////////////////////////////////////////////
e5bf64ae 4205 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4206 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
bf210566 4207 Int_t *ladderindex[fgklayernumber];
4208 Int_t index[fgklayernumber] = {8,9};
4209 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4210 for(Int_t i=0; i<fgklayernumber; i++)
4211 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4212 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4213 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4214 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4215 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4216 }
44285dfa 4217 /////////////////////////////////////////////////////////////
bf210566 4218 // Deallocating memory
4219 /////////////////////////////////////////////////////////////
7b208ef4 4220 for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
d7599219 4221}
4222////////////////////////////////////////////////////////////////////////////////
4223void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4224 /////////////////////////////////////////////////////////////
4225 // Insert the layer 5 in the mother volume.
4226 /////////////////////////////////////////////////////////////
4227 if (! moth) {
160835d5 4228 AliError("Can't insert layer5, mother is null!\n");
44285dfa 4229 return;
4230 };
bf210566 4231 if(!fSSDLayer5) SetLayer();
4232 fMotherVol = moth;
4233 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4234 + fgkLay5CenterITSPosition);
4235 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4236 }
d7599219 4237////////////////////////////////////////////////////////////////////////////////
4238void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4239 /////////////////////////////////////////////////////////////
4240 // Insert the layer 6 in the mother volume.
4241 /////////////////////////////////////////////////////////////
4242 if (! moth) {
160835d5 4243 AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
44285dfa 4244 return;
4245 };
bf210566 4246 if(!fSSDLayer6) SetLayer();
4247 fMotherVol = moth;
4248 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4249 + fgkLay6CenterITSPosition);
4250 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4251 }
bf210566 4252 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4253 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4254 /////////////////////////////////////////////////////////////
4255 // Method generating the Arc structure of Ladder Support
4256 /////////////////////////////////////////////////////////////
4257 const Int_t kssdlayladdernumber[fgklayernumber] =
4258 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4259 Double_t mountingsupportedge[fgklayernumber];
4260 Double_t mountingblockratio[fgklayernumber];
4261 Double_t theta[fgklayernumber];
4262 Double_t phi[fgklayernumber];
4263 Double_t psi0[fgklayernumber];
4264 Double_t deltapsi[fgklayernumber];
4265 TVector3* mountingsupportedgevector[fgklayernumber];
4266 for(Int_t i=0; i<fgklayernumber; i++){
4267 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4268 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4269 * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4270 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4271 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4272 / kssdlayladdernumber[i])));
4273 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4274 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4275 mountingsupportedgevector[i] = new TVector3();
60e55aee 4276 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4277 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4278 (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4279 (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
9b0c60ab 4280 psi0[i] = 0.5*TMath::Pi()-phi[i];
4281 deltapsi[i] = (theta[i]+phi[i])/nedges;
4282 }
4283 TVector3** vertex[fgklayernumber];
4284 TList* vertexlist[fgklayernumber];
4285 Int_t indexedge[fgklayernumber] = {0,0};
4286 for(Int_t i=0; i<fgklayernumber; i++){
4287 vertex[i] = new TVector3*[nedges+1];
4288 vertexlist[i] = new TList();
4289 }
4290 for(Int_t i=0; i<fgklayernumber; i++){
4291 for(Int_t j=0; j<nedges+1; j++){
4292 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4293 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4294 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4295 vertexlist[i]->Add(vertex[i][j]);
4296 }
4297 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4298 }
4299 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4300 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4301 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4302 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4303 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4304 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4305 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4306 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4307 for(Int_t i=0; i<fgklayernumber; i++){
4308 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4309 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4310 xcentervertex[i] = new Double_t[indexedge[i]+3];
4311 ycentervertex[i] = new Double_t[indexedge[i]+3];
4312 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4313 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4314 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4315 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4316 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4317 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4318 ((TVector3*)vertexlist[i]->At(j))->X();
4319 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4320 ((TVector3*)vertexlist[i]->At(j))->Y();
4321 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4322 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4323 if(j<indexedge[i]+1){
4324 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4325 ((TVector3*)vertexlist[i]->At(j))->X();
4326 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4327 ((TVector3*)vertexlist[i]->At(j))->Y();
4328 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4329 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4330 }
4331 }
4332 xsidevertex[i][1] = xsidevertex[i][0];
4333 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4334 xsidevertex[i][2] = xsidevertex[i][3];
4335 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4336 xcentervertex[i][1] = xcentervertex[i][0];
4337 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4338 xcentervertex[i][2] = xcentervertex[i][3];
4339 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4340 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4341 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4342 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4343 ycenterlowervertex[i][0] = ysidevertex[i][0];
4344 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4345 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4346 }
4347 /////////////////////////////////////////////////////////////
4348 // Building the Arc Structure of Ladder Supports
4349 /////////////////////////////////////////////////////////////
4350 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4351 TGeoXtru* centermountingsupportshape[fgklayernumber];
4352 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4353 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4354 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4355 TGeoVolume* centermountingblocksupport[fgklayernumber];
4356 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4357 TGeoVolume* centerladdersupportpiece[fgklayernumber];
a3f8715e 4358 char sidemountingblockname[100];
4359 char centermountingblockname[100];
4360 char sideladdersupportpiecename[100];
4361 char centerladdersupportpiecename[100];
9b0c60ab 4362 for(Int_t i=0; i<fgklayernumber; i++){
045be90c 4363 snprintf(sidemountingblockname,100,"MountingBlockSupportSideLay%dArc",i+5);
4364 snprintf(centermountingblockname,100,"MountingBlockSupportCenterLay%dArc",i+5);
4365 snprintf(sideladdersupportpiecename,100,"SideLadderSupportPieceLay%d",i+5);
4366 snprintf(centerladdersupportpiecename,100,"CenterLadderSupportPieceLay%d",i+5);
4367 sidemountingblocksupportshape[i] = new TGeoXtru(2);
9b0c60ab 4368 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4369 xsidevertex[i],ysidevertex[i]);
4370 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4371 -fgkMountingBlockSupportWidth[0]);
4372 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4373 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4374 sidemountingblocksupportshape[i],
4375 fSSDAlCoolBlockMedium);
4376 sidemountingblocksupport[i]->SetLineColor(9);
4377 centermountingsupportshape[i] = new TGeoXtru(2);
4378 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4379 xcentervertex[i],ycentervertex[i]);
4380 centermountingsupportshape[i]->DefineSection(0,0.);
4381 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4382 -fgkMountingBlockSupportWidth[0]);
160835d5 4383
9b0c60ab 4384 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4385 centermountingsupportshape[i],
4386 fSSDAlCoolBlockMedium);
4387 centermountingblocksupport[i]->SetLineColor(9);
4388 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4389 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4390 xsidelowervertex[i],ysidelowervertex[i]);
4391 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4392 -fgkMountingBlockSupportWidth[0]);
4393 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4394 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4395 sideladdersupportpieceshape[i],
e21cdd03 4396 fSSDCarbonFiberMedium);
9b0c60ab 4397 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4398 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4399 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4400 xcenterlowervertex[i],ycenterlowervertex[i]);
4401 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4402 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4403 -fgkMountingBlockSupportWidth[0]);
4404 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4405 centerladdersupportpieceshape[i],
e21cdd03 4406 fSSDCarbonFiberMedium);
9b0c60ab 4407 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4408 }
4409 /////////////////////////////////////////////////////////////
4410 // Building the Up Structure of Ladder Supports
4411 /////////////////////////////////////////////////////////////
4412 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4413 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4414 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4415 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4416 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4417 //////////////////////////////////////////////////////////
4418 // Setting the volume for TGeoXtru Mounting Block Piece
4419 //////////////////////////////////////////////////////////
4420 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4421 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4422 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4423 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4424 TGeoVolume* mountingblockpieceup[fgklayernumber];
4425 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4426 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4427 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4428 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
a3f8715e 4429 char mountingblockpiecedownname[100];
4430 char mountingblockpieceupname[100];
9b0c60ab 4431 for(Int_t i=0; i<fgklayernumber; i++){
4432 ///////////////////////////
4433 // Mounting Block Down Vertex
4434 ///////////////////////////
4435 mountingblockpiecedownshape[i] = new TGeoXtru(2);
045be90c 4436 snprintf(mountingblockpiecedownname,100,"MountingBlockPieceDownLay%d",i+5);
9b0c60ab 4437 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4438 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4439 + fgkMountingBlockSupportDownHeight
4440 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4441 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4442 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4443 + fgkSSDMountingBlockHeight[1]
4444 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4445 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4446 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4447 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4448 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4449 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4450 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4451 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4452 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4453 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4454 + fgkSSDMountingBlockHeight[2]
4455 - fgkSSDMountingBlockHeight[0];
4456 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4457 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4458 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4459 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4460 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4461 mountingblockpiecedownyvertex[i]);
4462 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4463 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4464 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
e21cdd03 4465 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
9b0c60ab 4466 mountingblockpiecedown[i]->SetLineColor(fColorG10);
160835d5 4467
9b0c60ab 4468 ///////////////////////////
4469 // Mounting Block Up Vertex
4470 ///////////////////////////
4471 mountingblockpieceupshape[i] = new TGeoXtru(2);
045be90c 4472 snprintf(mountingblockpieceupname,100,"MountingBlockPieceUpLay%d",i+5);
9b0c60ab 4473 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4474 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4475 + fgkMountingBlockSupportUpHeight[i]
4476 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4477 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4478 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4479 + fgkSSDMountingBlockHeight[1]
4480 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4481 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4482 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4483 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4484 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4485 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4486 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4487 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4488 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4489 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4490 + fgkSSDMountingBlockHeight[2]
4491 - fgkSSDMountingBlockHeight[0];
4492 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4493 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4494 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4495 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
160835d5 4496
9b0c60ab 4497 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4498 mountingblockpieceupyvertex[i]);
4499 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4500 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4501 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
e21cdd03 4502 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
9b0c60ab 4503 mountingblockpieceup[i]->SetLineColor(fColorG10);
4504 }
4505 ///////////////////////////////////////////////////////////////////
4506 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4507 ///////////////////////////////////////////////////////////////////
4508 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4509 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4510 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4511 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4512 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4513 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4514 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4515 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
a3f8715e 4516 char mountingblocksupportrapezoidowname[100];
4517 char mountingblocksupportrapezoidupname[100];
9b0c60ab 4518 Double_t scalefactor = 3./4.;
4519 for(Int_t i=0; i<fgklayernumber; i++){
4520 ////////////////////////////////////////////
4521 // Mounting Block Support Down Trapezoid Vertex
4522 ////////////////////////////////////////////
4523 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4524 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4525 - mountingsupportedge[i];
4526 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4527 mountingblocksupportrapezoidownxvertex[i][1] =
4528 mountingblocksupportrapezoidownxvertex[i][0];
4529 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4530 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4531 - mountingblockpiecedownyvertex[i][0]);
4532 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4533 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4534 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4535 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4536 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4537 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
160835d5 4538
9b0c60ab 4539 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4540 mountingblocksupportrapezoidownyvertex[i]);
4541 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4542 -fgkMountingBlockSupportWidth[0]);
4543 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
045be90c 4544 snprintf(mountingblocksupportrapezoidowname,100,"MountingBlockSuppTrapezoidDownLay%d",i+5);
9b0c60ab 4545 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
e21cdd03 4546 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4547 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4548 ////////////////////////////////////////////
4549 // Mounting Block Support Up Trapezoid Vertex
4550 ////////////////////////////////////////////
4551 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4552 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4553 - mountingsupportedge[i];
4554 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4555 mountingblocksupportrapezoidupxvertex[i][1] =
4556 mountingblocksupportrapezoidupxvertex[i][0];
4557 mountingblocksupportrapezoidupyvertex[i][1] =
4558 mountingblockpieceupyvertex[i][0]
4559 + scalefactor*(mountingblockpieceupyvertex[i][1]
4560 - mountingblockpieceupyvertex[i][0]);
4561 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4562 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4563 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4564 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4565 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4566 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
160835d5 4567
9b0c60ab 4568 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4569 mountingblocksupportrapezoidupyvertex[i]);
4570 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4571 -fgkMountingBlockSupportWidth[0]);
4572 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
045be90c 4573 snprintf(mountingblocksupportrapezoidupname,100,"MountingBlockSuppTrapezoidUpLay%d",i+5);
9b0c60ab 4574 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
e21cdd03 4575 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4576 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4577 }
4578 ///////////////////////////////////////////////////////////////////
4579 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4580 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4581 Double_t boxoriginup[fgklayernumber][2][3];
4582 Double_t boxorigindown[fgklayernumber][2][3];
a3f8715e 4583 char mountingblocksupportboxdownname[100];
4584 char mountingblocksupportboxupname[100];
9b0c60ab 4585 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4586 mountingblocksupportrot->SetAngles(90.,180.,-90);
4587 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4588 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4589 TGeoHMatrix* laddersupportmatrix[2];
4590 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4591 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4592 /////////////////////////////////////////////////////////////
4593 // Creating Mother Volume for Containment
4594 /////////////////////////////////////////////////////////////
4595 Double_t *xmothervertex[fgklayernumber];
4596 Double_t *ymothervertex[fgklayernumber];
4597 for(Int_t i=0; i<fgklayernumber; i++){
4598 xmothervertex[i] = new Double_t[8];
4599 ymothervertex[i] = new Double_t[8];
4600 }
4601 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4602 TGeoVolume* downmotherladdersupport[fgklayernumber];
4603 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
160835d5 4604 TGeoVolume* upmotherladdersupport[fgklayernumber];
a3f8715e 4605 char upmotheladdersupportname[100];
4606 char downmotheladdersupportname[100];
9b0c60ab 4607 for(Int_t i=0; i<fgklayernumber; i++){
4608 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4609 - mountingsupportedge[i];
4610 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4611 xmothervertex[i][1] = xmothervertex[i][0];
4612 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4613 + fgkMountingBlockSupportWidth[0];
4614 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4615 ymothervertex[i][2] = ymothervertex[i][1];
4616 xmothervertex[i][3] = xmothervertex[i][2];
4617 ymothervertex[i][3] = -ymothervertex[i][0];
4618 xmothervertex[i][4] = -xmothervertex[i][0];
4619 ymothervertex[i][4] = ymothervertex[i][3];
4620 xmothervertex[i][5] = xmothervertex[i][4];
4621 ymothervertex[i][5] = -ymothervertex[i][1];
4622 xmothervertex[i][6] = -xmothervertex[i][2];
4623 ymothervertex[i][6] = ymothervertex[i][5];
4624 xmothervertex[i][7] = xmothervertex[i][6];
4625 ymothervertex[i][7] = ymothervertex[i][0];
160835d5 4626
045be90c 4627 snprintf(downmotheladdersupportname,100,"LadderSupportDownLay%d",i+5);
4628 snprintf(upmotheladdersupportname,100,"LadderSupportUpLay%d",i+5);
160835d5 4629
4630 downmotherladdersupportshape[i] = new TGeoXtru(2);
9b0c60ab 4631 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4632 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
160835d5 4633 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
9b0c60ab 4634 + fgkMountingBlockSupportDownHeight
4635 + fgkSSDMountingBlockHeight[1]
4636 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4637 - fgkSSDModuleCoolingBlockToSensor
4638 - fgkSSDLadderVerticalDisalignment);
4639
4640// - fgkSSDModuleVerticalDisalignment);
4641 //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4642
4643 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4644 downmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4645 upmotherladdersupportshape[i] = new TGeoXtru(2);
4646 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4647 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4648 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4649 + fgkMountingBlockSupportUpHeight[i]
4650 + fgkSSDMountingBlockHeight[1]
4651 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4652 - fgkSSDModuleCoolingBlockToSensor
4653 - fgkSSDLadderVerticalDisalignment);
4654
4655 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4656 upmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4657 }
4658 for(Int_t i=0; i<fgklayernumber; i++){
4659 /////////////////////////
4660 // Setting the box origin
4661 /////////////////////////
4662 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4663 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4664 + 0.5*fgkMountingBlockSupportDownHeight
4665 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4666 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4667 - 0.5*fgkMountingBlockSupportWidth[0];
4668
4669 boxorigindown[i][1][0] = 0.0;
4670 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4671 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4672 - fgkMountingBlockSupportWidth[0]);
4673
4674 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4675 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4676 + 0.5*fgkMountingBlockSupportUpHeight[i]
4677 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4678 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4679 - 0.5*fgkMountingBlockSupportWidth[0];
4680
4681 boxoriginup[i][1][0] = 0.0;
160835d5 4682 boxoriginup[i][1][1] = boxoriginup[i][0][1];
9b0c60ab 4683 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4684 - fgkMountingBlockSupportWidth[0]);
4685
4686 /////////////////////////
4687 // Setting the boxes
4688 /////////////////////////
4689 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4690 + fgkSSDMountingBlockLength[0]),
160835d5 4691 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4692 0.5*fgkMountingBlockSupportWidth[0],
4693 boxorigindown[i][0]);
160835d5 4694 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4695 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4696 0.5*(fgkMountingBlockSupportWidth[1]
4697 - fgkMountingBlockSupportWidth[0]),
4698 boxorigindown[i][1]);
4699
4700 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4701 + fgkSSDMountingBlockLength[0]),
160835d5 4702 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4703 0.5*fgkMountingBlockSupportWidth[0],
4704 boxoriginup[i][0]);
160835d5 4705
9b0c60ab 4706 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
160835d5 4707 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4708 0.5*(fgkMountingBlockSupportWidth[1]
4709 - fgkMountingBlockSupportWidth[0]),
4710 boxoriginup[i][1]);
4711 ///////////////////////////////////////
160835d5 4712 // Adding the Volumes to Mother Volume
9b0c60ab 4713 ///////////////////////////////////////
4714 for(Int_t j=0; j<2; j++){
045be90c 4715 snprintf(mountingblocksupportboxdownname,100,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4716 snprintf(mountingblocksupportboxupname,100,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4717 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4718 mountingblocksupportboxdownshape[i][j],
4719 fSSDCarbonFiberMedium);
4720 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4721 mountingblocksupportboxupshape[i][j],
4722 fSSDCarbonFiberMedium);
9b0c60ab 4723 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4724 mountingblocksupportboxup[i][j]->SetLineColor(9);
4725 for(Int_t k=0; k<2; k++){
4726 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
160835d5 4727 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
9b0c60ab 4728 }
4729 }
4730 for(Int_t k=0; k<2; k++){
4731 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4732 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4733 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4734 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
160835d5 4735 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4736 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4737 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
160835d5 4738 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4739 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4740 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4741 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4742 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4743 }
4744 }
4745 TList* laddersupportlist = new TList();
4746 laddersupportlist->Add(downmotherladdersupport[0]);
4747 laddersupportlist->Add(upmotherladdersupport[0]);
4748 laddersupportlist->Add(downmotherladdersupport[1]);
4749 laddersupportlist->Add(upmotherladdersupport[1]);
4750 /////////////////////////////////////////////////////////////
4751 // Deallocating memory
4752 /////////////////////////////////////////////////////////////
4753 for(Int_t i=0; i<fgklayernumber; i++){
4754 for(Int_t j=0; j<nedges+1; j++)
4755 delete vertex[i][j];
4756 delete mountingsupportedgevector[i];
4757 delete [] vertex[i];
4758 delete vertexlist[i];
4759 delete [] xsidevertex[i];
4760 delete [] ysidevertex[i];
4761 delete [] xcentervertex[i];
4762 delete [] ycentervertex[i];
4763 delete [] xsidelowervertex[i];
4764 delete [] ysidelowervertex[i];
4765 delete [] xcenterlowervertex[i];
4766 delete [] ycenterlowervertex[i];
7b208ef4 4767 delete [] xmothervertex[i];
4768 delete [] ymothervertex[i];
9b0c60ab 4769 }
3e008bd7 4770 delete [] xsidevertex;
4771 delete [] ysidevertex;
4772 delete [] xcentervertex;
4773 delete [] ycentervertex;
4774 delete [] xsidelowervertex;
4775 delete [] ysidelowervertex;
4776 delete [] xcenterlowervertex;
4777 delete [] ycenterlowervertex;
9b0c60ab 4778 delete globalrefladdersupportrot;
4779 delete mountingblocksupportrot;
4780 /////////////////////
4781 return laddersupportlist;
4782}
4783 ////////////////////////////////////////////////////////////////////////////////
4784void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4785//////////////////////////////////////////
4786// Method Generating Ladder Support Ring
4787//////////////////////////////////////////
4788 if(!fCreateMaterials) CreateMaterials();
4789 if(!fTransformationMatrices) CreateTransformationMatrices();
4790 if(!fBasicObjects) CreateBasicObjects();
4791 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4792 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4793 const Int_t kssdlayladdernumber[fgklayernumber] =
4794 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4795 Double_t mountingsupportedge[fgklayernumber];
4796 Double_t mountingblockratio[fgklayernumber];
4797 Double_t theta[fgklayernumber];
4798 Double_t phi[fgklayernumber];
4799 for(Int_t i=0; i<fgklayernumber; i++){
4800 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4801 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4802 *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4803 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4804 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4805 / kssdlayladdernumber[i])));
4806 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4807 / fgkMountingBlockSupportRadius[i]);
4808 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4809 }
4810 TGeoRotation* globalrot = new TGeoRotation();
4811 globalrot->SetAngles(0.,-90.,0.);
4812 TGeoRotation** laddersupportrot[fgklayernumber];
4813 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4814 for(Int_t i=0; i<fgklayernumber; i++){
4815 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4816 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4817 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4818 laddersupportrot[i][j] = new TGeoRotation();
4819 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4820 switch(i){
4821 case 0: //Ladder of Layer5
4822 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4823 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4824 laddersupportmatrix[i][j]);
4825 break;
4826 case 1: //Ladder of Layer6
4827 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4828 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4829 laddersupportmatrix[i][j]);
4830 break;
4831 }
4832 }
4833 }
4834 /////////////////////////////////////////////////////////////
4835 // Creating Lower Ladder Support
4836 /////////////////////////////////////////////////////////////
4837 TVector3** ringsupportvertex[fgklayernumber];
4838 Double_t angle = 360./nedges;
4839 for(Int_t i=0; i<fgklayernumber; i++){
4840 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4841 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4842 * TMath::Cos(theta[i]));
4843 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4844 - mountingsupportedge[i],
4845 ringsupportvertex[i][0]->Y());
4846 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4847 ringsupportvertex[i][1]->Y());
4848 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4849 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4850 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4851 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4852 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4853 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4854 }
4855 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4856 for(Int_t j=0; j<nedges+1; j++){
4857 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
cd2243fb 4858 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
4859 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle));
9b0c60ab 4860 }
4861 }
4862 Double_t **xmothervertex = new Double_t*[fgklayernumber];
4863 Double_t **ymothervertex = new Double_t*[fgklayernumber];
4864 for(Int_t i=0; i<fgklayernumber; i++){
4865 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4866 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4867 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4868 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4869 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4870 }
4871 }
0e8760e5 4872////////////////////////////////////////////////////////////////////////////////
4873// Start Corrections 13/06/08
4874////////////////////////////////////////////////////////////////////////////////
a3f8715e 4875 char lowerladderpconsupportname[100];
0e8760e5 4876 TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4877 TGeoVolume* lowerladderpconsupport[fgklayernumber];
4878 Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4879 Double_t lowerladderpconradiusmax[fgklayernumber];
4880 Double_t lowerladderpconradiusmin[fgklayernumber];
4881 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4882 lowerladdersupportrot->SetAngles(90.,180.,-90);
4883 for(Int_t i=0; i<fgklayernumber; i++){
4884 lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4885 * TMath::Cos(theta[i]);
cd2243fb 4886 lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
0e8760e5 4887 }
4888 for(Int_t i=0; i<fgklayernumber; i++){
4889/////////////////////////// Modified Version ?///////////////////
4890 lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4891 for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
4892 lowerladderpconezsection[j],lowerladderpconradiusmin[i],
4893 lowerladderpconradiusmax[i]);
045be90c 4894 snprintf(lowerladderpconsupportname,100,"LowerLadderPConSupportNameLay%d",i+5);
0e8760e5 4895 lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
4896 lowerladderpconsupport[i]->SetLineColor(fColorAl);
4897 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
4898 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
4899 }
4900////////////////////////////////////////////////////////////////////////////////
4901// End Corrections 13/06/08
4902////////////////////////////////////////////////////////////////////////////////
4903 /*char lowerladdersupportname[30];
9b0c60ab 4904 TGeoXtru* lowerladdersupportshape[fgklayernumber];
4905 TGeoVolume* lowerladdersupport[fgklayernumber];
4906 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4907 lowerladdersupportrot->SetAngles(90.,180.,-90);
4908 for(Int_t i=0; i<fgklayernumber; i++){
4909 lowerladdersupportshape[i] = new TGeoXtru(2);
4910 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
4911 xmothervertex[i],ymothervertex[i]);
4912 lowerladdersupportshape[i]->DefineSection(0,0.);
4913 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4914 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
4915 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
4916 lowerladdersupportshape[i],fSSDSupportRingAl);
4917 lowerladdersupport[i]->SetLineColor(fColorAl);
4918 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
4919 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
0e8760e5 4920 }*/
9b0c60ab 4921 /////////////////////////////////////////////////////////////
4922 // Deallocating memory
4923 /////////////////////////////////////////////////////////////
4924 for(Int_t i=0; i<fgklayernumber; i++){
4925 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
4926 delete ringsupportvertex[i][j];
4927 delete [] ringsupportvertex[i];
4928 }
4929 for(Int_t i=0; i<fgklayernumber; i++){
4930 delete [] xmothervertex[i];
4931 delete [] ymothervertex[i];
4932 }
7b208ef4 4933 delete [] xmothervertex;
4934 delete [] ymothervertex;
9b0c60ab 4935 delete globalrot;
4936 for(Int_t i=0; i<fgklayernumber; i++){
4937 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
4938 delete laddersupportrot[i][j];
4939 delete [] laddersupportrot[i];
4940 }
4941 }
4942 ////////////////////////////////////////////////////////////////////////////////
4943 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
4944 /////////////////////////////////////////////////////////////
4945 // Method generating Endcap CoverPlate
4946 /////////////////////////////////////////////////////////////
4947 // Holes Definition
4948 ///////////////////
4949 Int_t nendcapcoverplateholedges = 30;
4950 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
4951 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
4952 0.5*fgkEndCapCoverPlateThickness};
851c0ce3 4953 TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
9b0c60ab 4954 nendcapcoverplateholedges,holesection);
4955 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 4956 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4957 endcapcoverplatesmallhole->SetLineColor(6);
851c0ce3 4958 TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
9b0c60ab 4959 nendcapcoverplateholedges,holesection);
4960 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 4961 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4962 endcapcoverplatebighole->SetLineColor(6);
4963 //////////////////////////
4964 // Screw Piece Definition
4965 //////////////////////////
4966 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
4967 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
4968 CosD(0.5*smallscrewangle),
4969 0.5*fgkEndCapCoverPlateThickness);
4970 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
4971 endcapsmallscrewpieceshape,
4972 fSSDCoolingTubePhynox);
4973 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
4974 ///////////////////
4975 // Box Definition
4976 ///////////////////
4977 TGeoBBox* endcapcoverplateboxshape[4];
4978 TGeoVolume* endcapcoverplatebox[4];
4979 Double_t boxorigin[5][3];
4980 boxorigin[0][0] = 0.;
4981 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
4982 boxorigin[0][2] = 0.;
4983
4984 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
4985 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
4986 boxorigin[1][2] = 0.;
4987
4988 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
4989 + fgkEndCapCoverPlateSmallHoleSeparation[1];
4990 boxorigin[2][1] = boxorigin[1][1];
4991 boxorigin[2][2] = 0.;
4992
4993 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
4994 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
4995 boxorigin[3][1] = boxorigin[1][1];
4996 boxorigin[3][2] = 0.;
4997
4998 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4999 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
5000 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
5001 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
5002
5003 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5004 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5005 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5006 + fgkEndCapCoverPlateSmallHoleRadius,
5007 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
5008
5009 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
5010 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5011 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5012 + fgkEndCapCoverPlateSmallHoleRadius,
5013 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
5014
5015 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
5016 -2.*fgkEndCapCoverPlateSmallHoleRadius),
5017 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
5018 + fgkEndCapCoverPlateSmallHoleRadius,
5019 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
5020
5021 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 5022 fSSDAlCoolBlockMedium);
9b0c60ab 5023 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 5024 fSSDAlCoolBlockMedium);
9b0c60ab 5025 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 5026 fSSDAlCoolBlockMedium);
9b0c60ab 5027 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 5028 fSSDAlCoolBlockMedium);
9b0c60ab 5029 endcapcoverplatebox[0]->SetLineColor(6);
5030 endcapcoverplatebox[1]->SetLineColor(6);
5031 endcapcoverplatebox[2]->SetLineColor(6);
5032 endcapcoverplatebox[3]->SetLineColor(6);
5033 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
5034 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
5035 fgkEndCapCoverPlateSmallHoleRadius,
5036 0.5*fgkEndCapCoverPlateThickness,
5037 endcapfillingboxorigin);
5038 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 5039 fSSDAlCoolBlockMedium);
9b0c60ab 5040 endcapfillingbox->SetLineColor(6);
5041 ////////////////////////////
851c0ce3 5042 // Contour shape Definition
9b0c60ab 5043 ////////////////////////////
5044 const Int_t kcontourvertexnumber = 10;
5045 Double_t xcontourvertex[kcontourvertexnumber];
5046 Double_t ycontourvertex[kcontourvertexnumber];
5047 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
5048 xcontourvertex[1] = xcontourvertex[0];
5049 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5050 xcontourvertex[3] = xcontourvertex[2];
5051 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
5052 xcontourvertex[5] = xcontourvertex[4];
5053 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5054 xcontourvertex[7] = xcontourvertex[6];
5055 xcontourvertex[8] = xcontourvertex[4];
5056 xcontourvertex[9] = xcontourvertex[8];
5057 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5058 - (kendcapcoverplatesmallholenumber[1]-1)
5059 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5060 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5061 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5062 ycontourvertex[2] = ycontourvertex[1];
5063 ycontourvertex[3] = ycontourvertex[0];
5064 ycontourvertex[4] = ycontourvertex[3];
5065 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5066 ycontourvertex[6] = ycontourvertex[5];
5067 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5068 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5069 + fgkEndCapCoverPlateSmallHoleRadius;
5070 ycontourvertex[8] = ycontourvertex[7];
5071 ycontourvertex[9] = ycontourvertex[0];
851c0ce3 5072
5073 Double_t xboxin, dxboxin, yboxin, dyboxin;
5074 Double_t xboxout, dxboxout, yboxout, dyboxout;
5075 Double_t coordmin, coordmax;
5076 coordmin = -fgkEndCapCoverPlateLength[0];
5077 coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5078 xboxout = 0.5*(coordmin+coordmax);
5079 dxboxout = 0.5*(coordmax-coordmin);
5080 coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5081 - (kendcapcoverplatesmallholenumber[1]-1)
5082 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5083 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5084 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5085 yboxout = 0.5*(coordmin+coordmax);
5086 dyboxout = 0.5*(coordmax-coordmin);
5087 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5088 coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5089 xboxin = 0.5*(coordmin+coordmax);
5090 dxboxin = 0.5*(coordmax-coordmin);
5091 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5092 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5093 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5094 + fgkEndCapCoverPlateSmallHoleRadius;
5095 yboxin = 0.5*(coordmin+coordmax);
5096 dyboxin = 0.5*(coordmax-coordmin);
5097 new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5098 TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5099 xboxout, yboxout, 0.);
5100 trendCapCoverPlateContourboxout->RegisterYourself();
5101 new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5102 TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5103 xboxin, yboxin, 0.);
5104 trendCapCoverPlateContourboxin->RegisterYourself();
5105 TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5106 "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5107
e21cdd03 5108 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5109 fSSDAlCoolBlockMedium);
9b0c60ab 5110 contour->SetLineColor(6);
5111 /////////////////////////////
851c0ce3 5112 // Hole Contour Shape Definition
9b0c60ab 5113 ////////////////////////////
851c0ce3 5114 coordmin = xcontourvertex[0];
5115 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5116 xboxout = 0.5*(coordmin+coordmax);
5117 dxboxout = 0.5*(coordmax-coordmin);
5118 coordmin = ycontourvertex[1];
5119 coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5120 yboxout = 0.5*(coordmin+coordmax);
5121 dyboxout = 0.5*(coordmax-coordmin);
5122 coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5123 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5124 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5125 xboxin = 0.5*(coordmin+coordmax);
5126 dxboxin = 0.5*(coordmax-coordmin);
5127 coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5128 - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5129 coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5130 yboxin = 0.5*(coordmin+coordmax);
5131 dyboxin = 0.5*(coordmax-coordmin);
5132 new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5133 TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5134 xboxout, yboxout, 0.);
5135 trendCapCoverPlateContourboxout1->RegisterYourself();
5136 new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5137 TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5138 xboxin, yboxin, 0.);
5139 trendCapCoverPlateContourboxin1->RegisterYourself();
5140 TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5141 "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5142
5143
5144 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5145 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5146 xboxout = 0.5*(coordmin+coordmax);
5147 dxboxout = 0.5*(coordmax-coordmin);
5148 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5149 - fgkEndCapCoverPlateWidth[0]);
5150 coordmax = ycontourvertex[0];
5151 yboxout = 0.5*(coordmin+coordmax);
5152 dyboxout = 0.5*(coordmax-coordmin);
5153 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5154 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5155 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5156 xboxin = 0.5*(coordmin+coordmax);
5157 dxboxin = 0.5*(coordmax-coordmin);
5158 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5159 - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5160 - fgkEndCapCoverPlateWidth[0]
5161 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5162 coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5163 yboxin = 0.5*(coordmin+coordmax);
5164 dyboxin = 0.5*(coordmax-coordmin);
5165 new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5166 TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5167 xboxout, yboxout, 0.);
5168 trendCapCoverPlateContourboxout2->RegisterYourself();
5169 new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5170 TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5171 xboxin, yboxin, 0.);
5172 trendCapCoverPlateContourboxin2->RegisterYourself();
5173 TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5174 "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5175
5176// const Int_t kholecontourvertexnumber = 10;
5177
9b0c60ab 5178 Double_t xholecontourvertex[2][kcontourvertexnumber];
5179 Double_t yholecontourvertex[2][kcontourvertexnumber];
5180 xholecontourvertex[0][0] = xcontourvertex[0];
5181 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5182 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5183 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5184 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5185 + 0.5*(fgkEndCapCoverPlateLength[2]
5186 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5187 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5188 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5189 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5190 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5191 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5192 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5193
5194 yholecontourvertex[0][0] = ycontourvertex[1];
5195 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5196 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5197 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5198 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5199 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5200 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5201 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5202 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5203 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5204 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5205
5206 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5207 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5208 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5209 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5210 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5211 + 0.5*(fgkEndCapCoverPlateLength[2]
5212 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5213 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5214 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5215 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5216 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5217 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5218 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5219
5220 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5221 - fgkEndCapCoverPlateWidth[0]);
5222 yholecontourvertex[1][1] = ycontourvertex[0];
5223 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5224 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5225 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5226 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5227 - fgkEndCapCoverPlateWidth[0]
5228 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5229 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5230 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5231 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5232 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5233
9b0c60ab 5234 TGeoVolume* holecontour[2];
851c0ce3 5235 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
e21cdd03 5236 fSSDAlCoolBlockMedium);
9b0c60ab 5237 holecontour[0]->SetLineColor(6);
851c0ce3 5238 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
e21cdd03 5239 fSSDAlCoolBlockMedium);
9b0c60ab 5240 holecontour[1]->SetLineColor(6);
5241 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5242 + fgkEndCapCoverPlateLength[2],0.,0.);
5243 TGeoTranslation* bigholetrans[3];
5244 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5245 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5246 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5247 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5248 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5249 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5250 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5251 /////////////////////////////////
5252 // Mother Volume Xtru Definition
5253 /////////////////////////////////
5254 const Int_t kmothervertexnumber = 12;
5255 Double_t xmothervertex[kmothervertexnumber];
5256 Double_t ymothervertex[kmothervertexnumber];
5257 xmothervertex[0] = xcontourvertex[0];
5258 xmothervertex[1] = xmothervertex[0];
5259 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5260 xmothervertex[3] = xmothervertex[2];
5261 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5262 xmothervertex[5] = xmothervertex[4];
5263 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5264 xmothervertex[7] = xmothervertex[6];
5265 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5266 + fgkEndCapCoverPlateLength[2];
5267 xmothervertex[9] = xmothervertex[8];
5268 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5269 xmothervertex[11] = xmothervertex[10];
5270
5271 ymothervertex[0] = ycontourvertex[0];
5272 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5273 ymothervertex[2] = ymothervertex[1];
5274 ymothervertex[3] = ycontourvertex[1];
5275 ymothervertex[4] = ymothervertex[3];
5276 ymothervertex[5] = ymothervertex[1];
5277 ymothervertex[6] = ymothervertex[5];
5278 ymothervertex[7] = ymothervertex[0];
5279 ymothervertex[8] = ymothervertex[7];
5280 ymothervertex[9] = ymothervertex[8]
5281 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5282 ymothervertex[10] = ymothervertex[9];
5283 ymothervertex[11] = ymothervertex[8];
5284 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5285 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5286 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5287 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5288 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5289 ////////////////////////////////////////
5290 // Adding Nodes
5291 ////////////////////////////////////////
5292// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5293 TGeoTranslation*** endcapcoverplatesmallholetrans;
5294 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5295 Double_t transx[4] = {0,
5296 fgkEndCapCoverPlateSmallHoleSeparation[0],
5297 fgkEndCapCoverPlateSmallHoleSeparation[0]
5298 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5299 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5300 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5301 Int_t index = 0;
5302 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5303 endcapcoverplatesmallholetrans[i] =
5304 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5305 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5306 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5307 endcapcoverplatesmallholetrans[i][j] =
5308 new TGeoTranslation(transx[i],
5309 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5310 if(index!=10){
5311 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5312 index,endcapcoverplatesmallholetrans[i][j]);
5313 mothercoverplate->AddNode(endcapsmallscrewpiece,
5314 index,endcapcoverplatesmallholetrans[i][j]);
5315 }
5316 if(j<kendcapcoverplatesmallholenumber[1]-1)
5317 mothercoverplate->AddNode(endcapcoverplatebox[0],
5318 index,endcapcoverplatesmallholetrans[i][j]);
5319 }
5320 }
5321 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5322 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5323 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5324 mothercoverplate->AddNode(endcapfillingbox,1);
5325 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5326 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5327 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5328 mothercoverplate->AddNode(holecontour[0],1);
5329 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5330 mothercoverplate->AddNode(holecontour[1],1);
5331 mothercoverplate->AddNode(contour,1);
045be90c 5332
5333 for (Int_t i = 0; i < kendcapcoverplatesmallholenumber[0]; i++)
5334 delete [] endcapcoverplatesmallholetrans[i];
5335 delete [] endcapcoverplatesmallholetrans;
9b0c60ab 5336 /////////////////////////////////
5337 return mothercoverplate;
5338 }
5339 ////////////////////////////////////////////////////////////////////////////////
5340 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5341 /////////////////////////////////////////////////////////////
5342 // Getting EndCap Cooling Tube
5343 /////////////////////////////////////////////////////////////
5344 TGeoTorus* endcapcoolingtubetorushape[5];
5345 TGeoVolume* endcapcoolingtubetorus[5];
5346 TGeoTube* endcapcoolingtubeshape[4];
5347 TGeoVolume* endcapcoolingtube[4];
a3f8715e 5348 char endcapcoolingtubetorusname[100];
5349 char endcapcoolingtubename[100];
9b0c60ab 5350 TGeoTorus* endcapcoolingwatertubetorushape[5];
5351 TGeoVolume* endcapcoolingwatertubetorus[5];
5352 TGeoTube* endcapcoolingwatertubeshape[4];
5353 TGeoVolume* endcapcoolingwatertube[4];
a3f8715e 5354 char endcapcoolingwatertubetorusname[100];
5355 char endcapcoolingwatertubename[100];
9b0c60ab 5356 for(Int_t i=0; i<5; i++){
045be90c 5357 snprintf(endcapcoolingtubetorusname,100,"EndCapCoolingTubeTorus%d",i+1);
5358 snprintf(endcapcoolingtubename,100,"EndCapCoolingTube%d",i+1);
5359 snprintf(endcapcoolingwatertubetorusname,100,"EndCapCoolingWaterTubeTorus%d",i+1);
5360 snprintf(endcapcoolingwatertubename,100,"EndCapCoolingWaterTube%d",i+1);
5361 if(i==3){
5362 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5363 fgkEndCapCoolingTubeRadiusMin,
5364 fgkEndCapCoolingTubeRadiusMax,
5365 90.0,fgkEndCapCoolingTubeAngle[3]);
5366 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5367 0.,fgkEndCapCoolingTubeRadiusMin,
5368 90.0,fgkEndCapCoolingTubeAngle[3]);
5369 }
5370 else{
5371 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5372 :fgkEndCapCoolingTubeAxialRadius[1],
5373 fgkEndCapCoolingTubeRadiusMin,
5374 fgkEndCapCoolingTubeRadiusMax,
5375 0.,fgkEndCapCoolingTubeAngle[i]);
5376 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5377 :fgkEndCapCoolingTubeAxialRadius[1],
5378 0.,fgkEndCapCoolingTubeRadiusMin,
5379 0.,fgkEndCapCoolingTubeAngle[i]);
9b0c60ab 5380 }
9b0c60ab 5381 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5382 endcapcoolingtubetorushape[i],
5383 fSSDCoolingTubePhynox);
5384 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5385 endcapcoolingwatertubetorushape[i],
5386 fSSDCoolingTubeWater);
5387 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5388 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5389 if(i<4){
5390 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5391 fgkEndCapCoolingTubeRadiusMax,
5392 0.5*fgkEndCapCoolingTubeLength[i]);
5393 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5394 0.5*fgkEndCapCoolingTubeLength[i]);
5395 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5396 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5397 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5398 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5399 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5400 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5401 }
5402 }
5403 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5404 /////////////////////////////////////////
5405 // Transformation for Volume Positioning
5406 /////////////////////////////////////////
5407 TGeoCombiTrans* coolingtubecombitrans[6];
5408 TGeoRotation* coolingtuberot[8];
5409 TGeoTranslation* coolingtubetrans[6];
5410 TGeoHMatrix* coolingtubematrix[4];
5411 TGeoCombiTrans* torustubecombitrans[4];
5412 TGeoRotation* torustuberot[7];
5413 TGeoTranslation* torustubetrans[4];
5414 TGeoHMatrix* torustubematrix[5];
5415 TGeoCombiTrans* coolingwatertubecombitrans[6];
5416 TGeoRotation* coolingwatertuberot[8];
5417 TGeoTranslation* coolingwatertubetrans[6];
5418 TGeoHMatrix* coolingwatertubematrix[4];
5419 TGeoCombiTrans* toruswatertubecombitrans[4];
5420 TGeoRotation* toruswatertuberot[7];
5421 TGeoTranslation* toruswatertubetrans[4];
5422 TGeoHMatrix* toruswatertubematrix[5];
5423 for(Int_t i=0; i<8; i++){
5424 if(i<6){
5425 coolingtubetrans[i] = new TGeoTranslation();
5426 coolingwatertubetrans[i] = new TGeoTranslation();
5427 }
5428 if(i<8){
5429 coolingtuberot[i] = new TGeoRotation();
5430 coolingwatertuberot[i] = new TGeoRotation();
5431 }
5432 if(i<4){
5433 torustubetrans[i] = new TGeoTranslation();
5434 toruswatertubetrans[i] = new TGeoTranslation();
5435 }
5436 if(i<7){
5437 torustuberot[i] = new TGeoRotation();
5438 toruswatertuberot[i] = new TGeoRotation();
5439 }
5440 }
5441 /////////////////////////////////////////
5442 // Transformation for Inox Volume Positioning
5443 /////////////////////////////////////////
5444 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5445 -endcapcoolingtubeshape[0]->GetDz(),0.);
5446 coolingtuberot[0]->SetAngles(0.,90.,0.);
5447 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5448 *coolingtuberot[0]);
5449
5450 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5451 coolingtuberot[1]->SetAngles(0.,90.,0.);
5452 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5453 *coolingtuberot[1]);
5454
5455 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5456 *CosD(fgkEndCapCoolingTubeAngle[0]),
5457 fgkEndCapCoolingTubeAxialRadius[0]
5458 *SinD(fgkEndCapCoolingTubeAngle[0]),
5459 0.);
5460 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5461 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5462 *coolingtuberot[2]);
5463
5464 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5465 * (*coolingtubecombitrans[1]));
5466
5467 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5468 endcapcoolingtubeshape[1]->GetDz());
5469 torustuberot[0]->SetAngles(0.,90.,0.);
5470 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5471
5472 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5473
5474 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5475 -endcapcoolingtubeshape[2]->GetDz(),0.);
5476 coolingtuberot[3]->SetAngles(0.,90.,0.);
5477 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5478 *coolingtuberot[3]);
5479 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5480 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5481 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5482
5483 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5484 endcapcoolingtubeshape[2]->GetDz());
5485 torustuberot[1]->SetAngles(0.,90.,0.);
5486 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5487 torustuberot[2]->SetAngles(180.,0.,0.);
5488 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5489 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5490
5491 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5492 -fgkEndCapCoolingTubeAxialRadius[0]);
5493 torustuberot[3]->SetAngles(0.,90.,0.);
5494 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5495 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5496 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5497 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5498
5499 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5500 fgkEndCapCoolingTubeAxialRadius[0],0.);
5501 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5502 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5503 *coolingtuberot[5]);
5504 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5505 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5506 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5507
5508 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5509 endcapcoolingtubeshape[0]->GetDz());
5510 torustuberot[5]->SetAngles(0.,90.,0.);
5511 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5512 torustuberot[6]->SetAngles(-90.,0.,0.);
5513 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5514 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5515
5516 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5517 endcapcoolingtubeshape[3]->GetDz(),0.);
5518 coolingtuberot[6]->SetAngles(0.,90.,0.);
5519 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5520 *coolingtuberot[6]);
5521 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5522 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5523 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5524 /////////////////////////////////////////
5525 // Transformation for Water Volume Positioning
5526 /////////////////////////////////////////
5527 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5528 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5529 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5530 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5531 *coolingwatertuberot[0]);
5532
5533 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5534 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5535 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5536 *coolingwatertuberot[1]);
5537
5538 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5539 *CosD(fgkEndCapCoolingTubeAngle[0]),
5540 fgkEndCapCoolingTubeAxialRadius[0]
5541 *SinD(fgkEndCapCoolingTubeAngle[0]),
5542 0.);
5543 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5544 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5545 *coolingwatertuberot[2]);
5546
5547 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5548 * (*coolingwatertubecombitrans[1]));
5549
5550 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5551 endcapcoolingwatertubeshape[1]->GetDz());
5552 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5553 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5554 *toruswatertuberot[0]);
5555
5556 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5557 * (*toruswatertubecombitrans[0]));
5558
5559 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5560 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5561 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5562 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5563 *coolingwatertuberot[3]);
5564 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5565 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5566 * (*coolingwatertubecombitrans[3]));
5567 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5568
5569 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5570 endcapcoolingwatertubeshape[2]->GetDz());
5571 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5572 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5573 *toruswatertuberot[1]);
5574 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5575 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5576 * (*toruswatertubecombitrans[1]));
5577 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5578
5579 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5580 -fgkEndCapCoolingTubeAxialRadius[0]);
5581 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5582 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5583 *toruswatertuberot[3]);
5584 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5585 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5586 * (*toruswatertubecombitrans[2]));
5587 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5588
5589 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5590 fgkEndCapCoolingTubeAxialRadius[0],0.);
5591 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5592 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5593 *coolingwatertuberot[5]);
5594 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5595 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5596 * (*coolingwatertubecombitrans[4]));
5597 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5598
5599 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5600 endcapcoolingwatertubeshape[0]->GetDz());
5601 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5602 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5603 *toruswatertuberot[5]);
5604 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5605 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5606 * (*toruswatertubecombitrans[3]));
5607 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5608
5609 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5610 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5611 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5612 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5613 *coolingwatertuberot[6]);
5614 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5615 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5616 * (*coolingwatertubecombitrans[5]));
5617 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5618 /////////////////////////////////////////
5619 // Positioning Volumes
5620 /////////////////////////////////////////
5621 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5622 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5623
5624 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5625 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5626
5627 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5628 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5629
5630 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5631 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5632
5633 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5634 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5635
5636 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5637 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5638
5639 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5640 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5641
5642 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5643 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5644
5645 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5646 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5647
5648 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5649 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5650 /////////////////////////////////////////////////////////////
5651 // Deallocating memory
5652 /////////////////////////////////////////////////////////////
5653 for(Int_t i=0; i<8; i++){
5654 if(i<6){
5655 delete coolingtubetrans[i];
5656 delete coolingwatertubetrans[i];
5657 if(i!=0){
5658 delete coolingtubecombitrans[i];
5659 delete coolingwatertubecombitrans[i];
5660 }
5661 }
5662 if(i<8){
5663 delete coolingtuberot[i];
5664 delete coolingwatertuberot[i];
5665 }
5666 if(i<4){
5667 delete torustubetrans[i];
5668 delete toruswatertubetrans[i];
5669 delete torustubecombitrans[i];
5670 delete toruswatertubecombitrans[i];
5671 }
5672 if(i<7){
5673 delete torustuberot[i];
5674 delete toruswatertuberot[i];
5675 }
5676 }
5677 /////////////////////////////////////////////////////////////
5678 return endcapcoolingtubemother;
5679 }
5680 ////////////////////////////////////////////////////////////////////////////////
5681 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5682 /////////////////////////////////////////////////////////////
5683 // Getting EndCap Cover Side
5684 /////////////////////////////////////////////////////////////
5685 const Int_t kendcapcoverholenumber[2] = {7,5};
5686 const Int_t kvertexnumber = 15;
5687 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5688 xvertex[0] = 0.0;
5689 xvertex[1] = xvertex[0];
5690 xvertex[2] = fgkEndCapSideCoverLength[0];
5691 xvertex[3] = fgkEndCapSideCoverLength[1];
5692 xvertex[4] = xvertex[3];
5693 xvertex[5] = fgkEndCapSideCoverLength[2];
5694 xvertex[6] = xvertex[5];
5695 xvertex[7] = xvertex[2];
5696 xvertex[8] = xvertex[7];
5697 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5698 xvertex[10] = xvertex[9];
5699 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5700 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5701 * fgkEndCapSideCoverLength[4];
5702 xvertex[12] = xvertex[11];
5703 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5704 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5705 * fgkEndCapSideCoverLength[4];
5706 xvertex[14] = xvertex[13];
5707 yvertex[0] = 0.0;
5708 yvertex[1] = fgkEndCapSideCoverWidth[0];
5709 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5710 yvertex[3] = yvertex[2];
5711 yvertex[4] = fgkEndCapSideCoverWidth[1];
5712 yvertex[5] = yvertex[4];
5713 yvertex[6] = yvertex[0];
5714 yvertex[7] = yvertex[6];
5715 yvertex[8] = fgkEndCapSideCoverWidth[6];
5716 yvertex[9] = yvertex[8];
5717 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5718 yvertex[11] = yvertex[10];
5719 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5720 yvertex[13] = yvertex[12];
5721 yvertex[14] = yvertex[6];
851c0ce3 5722 TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5723 endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5724 endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5725 endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5726 endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5727 TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5728 endcapsidecovershapein->SetName("endcapsidecovershapein");
5729 endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5730 endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5731 endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5732
5733
5734 TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
9b0c60ab 5735 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5736 endcapsidecovershape,fSSDCoolingTubePhynox);
5737 endcapsidecover->SetLineColor(fColorPhynox);
5738 ////////////////////////////////////////////
5739 // Defininition of Mother Volume
5740 ////////////////////////////////////////////
5741 const Int_t kmothervertexnumber = 7;
5742 Double_t xmothervertex[kmothervertexnumber];
5743 Double_t ymothervertex[kmothervertexnumber];
5744 for(Int_t i=0; i<kmothervertexnumber; i++){
5745 xmothervertex[i] = xvertex[i];
5746 ymothervertex[i] = yvertex[i];
5747 }
5748 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5749 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5750 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5751 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5752 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5753 endcapsidecovermothershape,fSSDAir);
5754 ////////////////////////////////////////////
5755 endcapsidecovermother->AddNode(endcapsidecover,1);
5756 TGeoBBox* endcapsidecoverboxshape[4];
5757 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5758 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5759 0.5*fgkEndCapSideCoverLength[4],
5760 0.5*fgkEndCapSideCoverThickness);
5761 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5762 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5763 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5764 - fgkEndCapSideCoverLength[4]),
5765 0.5*fgkEndCapSideCoverThickness);
5766 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5767 0.5*fgkEndCapSideCoverLength[4],
5768 0.5*fgkEndCapSideCoverThickness);
5769 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5770 0.5*fgkEndCapSideCoverWidth[5],
5771 0.5*fgkEndCapSideCoverThickness);
5772 TGeoVolume* endcapsidecoverbox[4];
5773 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5774 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5775 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5776 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5777 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5778// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5779 TGeoTranslation** endcapsidecoverboxtrans;
5780 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5781 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5782 + fgkEndCapSideCoverLength[0],
5783 endcapsidecoverboxshape[0]->GetDY()
5784 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5785 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5786 + xvertex[11],
5787 endcapsidecoverboxshape[1]->GetDY()
5788 + yvertex[12],0.);
5789 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5790 + xvertex[11],
5791 endcapsidecoverboxshape[2]->GetDY()
5792 + yvertex[12]
5793 + 2.*endcapsidecoverboxshape[1]->GetDY()
5794 + fgkEndCapSideCoverWidth[5],0.);
5795 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5796 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5797 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5798 for(Int_t i=0; i<2; i++)
5799 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5800 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5801 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5802 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5803 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5804 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5805 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5806 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5807 }
5808 for(Int_t i=0; i<2; i++)
5809 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5810 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5811 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5812 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5813 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5814 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5815 +fgkEndCapSideCoverLength[4]),0.0);
5816 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5817 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5818 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5819 +i*(kendcapcoverholenumber[1]-1)+j]);
5820 }
b7bd9ab6 5821 delete [] endcapsidecoverboxtrans;
5822 return endcapsidecovermother;
9b0c60ab 5823 }
5824 ////////////////////////////////////////////////////////////////////////////////
5825 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5826 ////////////////////////////////////////////////////////////////////////////////
5827 // Method returning Interface Card A, Interface Card B, Supply Card
5828 ////////////////////////////////////////////////////////////////////////////////
5829 /////////////////////
5830 // Supply Card
5831 /////////////////////
5832 // Electronic Board Back Al Plane
5833 const Int_t kelectboardbackvertexnumber = 8;
5834 Double_t xelectboardback[kelectboardbackvertexnumber];
5835 Double_t yelectboardback[kelectboardbackvertexnumber];
5836 xelectboardback[0] = 0.0;
5837 xelectboardback[1] = xelectboardback[0];
5838 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5839 xelectboardback[3] = xelectboardback[2];
5840 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5841 xelectboardback[5] = xelectboardback[4];
5842 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5843 xelectboardback[7] = xelectboardback[6];
5844
5845 yelectboardback[0] = 0.0;
5846 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5847 yelectboardback[2] = yelectboardback[1];
5848 yelectboardback[3] = yelectboardback[0];
5849 yelectboardback[4] = yelectboardback[3];
5850 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5851 yelectboardback[6] = yelectboardback[5];
5852 yelectboardback[7] = yelectboardback[4];
5853 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5854 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5855 xelectboardback,yelectboardback);
5856 electboardbackshape->DefineSection(0,0.0);
5857 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5858 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5859 electboardbackshape,fSSDSupportRingAl);
5860 electboardback->SetLineColor(fColorAl);
5861 // Electronic Board Kapton Layer
5862 const Int_t kelectlayervertexnumber = 8;
5863 Double_t xelectlayer[kelectlayervertexnumber];
5864 Double_t yelectlayer[kelectlayervertexnumber];
5865 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5866 xelectlayer[1] = xelectlayer[0];
5867 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5868 xelectlayer[3] = xelectlayer[2];
5869 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5870
5871 yelectlayer[0] = 0.0;
5872 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5873 yelectlayer[2] = yelectlayer[1];
5874 yelectlayer[3] = yelectlayer[0];
5875 yelectlayer[4] = yelectlayer[3];
5876 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5877 yelectlayer[6] = yelectlayer[5];
5878 yelectlayer[7] = yelectlayer[4];
5879 TGeoXtru* electlayershape = new TGeoXtru(2);
5880 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5881 electlayershape->DefineSection(0,0.0);
5882 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5883 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5884 electlayershape,fSSDKaptonFlexMedium);
5885 electlayer->SetLineColor(fColorKapton);
5886 // JMD Connector Female
5887 const Int_t kjmdconnectorvertexnumber = 6;
5888 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5889 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5890 xjmdconnectorvertex[0] = 0.0;
5891 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5892 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5893 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5894 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5895 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5896
5897 yjmdconnectorvertex[0] = 0.0;
5898 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5899 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5900 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5901 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5902 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5903 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5904 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5905 yjmdconnectorvertex);
5906 jmdconnectorshape->DefineSection(0,0.0);
5907 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5908 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5909 jmdconnectorshape,fSSDMountingBlockMedium);
5910 jmdconnector->SetLineColor(fColorG10);
5911 // Top Cable Connector
5912 const Int_t kcableconnectorvertexnumber = 8;
5913 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5914 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5915 xconnectorvertex[0] = 0.0;
5916 xconnectorvertex[1] = xconnectorvertex[0];
5917 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5918 xconnectorvertex[3] = xconnectorvertex[2];
5919 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5920 - fgkEndCapCardCableConnectorLength[2];
5921 xconnectorvertex[5] = xconnectorvertex[4];
5922 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5923 xconnectorvertex[7] = xconnectorvertex[6];
5924
5925 yconnectorvertex[0] = 0.0;
5926 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5927 yconnectorvertex[2] = yconnectorvertex[1];
5928 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5929 yconnectorvertex[4] = yconnectorvertex[3];
5930 yconnectorvertex[5] = yconnectorvertex[1];
5931 yconnectorvertex[6] = yconnectorvertex[5];
5932 yconnectorvertex[7] = yconnectorvertex[0];
5933 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5934 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5935 yconnectorvertex);
5936 cableconnectorshape->DefineSection(0,0.0);
5937 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5938 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5939 cableconnectorshape,fSSDMountingBlockMedium);
5940 cableconnector->SetLineColor(fColorG10);
5941 // Strip Connection
5942 TGeoBBox* endcapstripconnectionshape =
5943 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5944 0.5*fgkEndCapStripConnectionThickness,
5945 0.5*fgkEndCapStripConnectionWidth);
5946 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5947 endcapstripconnectionshape,
5948 fSSDSupportRingAl);
5949 endcapstripconnection->SetLineColor(fColorAl);
5950 // Interface Card B
5951 const Int_t kcardBvertexnumber = 12;
5952 Double_t xcardBvertexnumber[kcardBvertexnumber];
5953 Double_t ycardBvertexnumber[kcardBvertexnumber];
5954
5955 xcardBvertexnumber[0] = 0.0;
5956 xcardBvertexnumber[1] = xcardBvertexnumber[0];
5957 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5958 xcardBvertexnumber[3] = xcardBvertexnumber[2];
5959 xcardBvertexnumber[4] = xcardBvertexnumber[1];
5960 xcardBvertexnumber[5] = xcardBvertexnumber[4];
5961 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5962 xcardBvertexnumber[7] = xcardBvertexnumber[6];
5963 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5964 xcardBvertexnumber[9] = xcardBvertexnumber[8];
5965 xcardBvertexnumber[10] = xcardBvertexnumber[7];
5966 xcardBvertexnumber[11] = xcardBvertexnumber[10];
5967
5968 ycardBvertexnumber[0] = 0.0;
5969 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
5970 ycardBvertexnumber[2] = ycardBvertexnumber[1];
5971 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5972 ycardBvertexnumber[4] = ycardBvertexnumber[3];
5973 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5974 ycardBvertexnumber[6] = ycardBvertexnumber[5];
5975 ycardBvertexnumber[7] = ycardBvertexnumber[4];
5976 ycardBvertexnumber[8] = ycardBvertexnumber[7];
5977 ycardBvertexnumber[9] = ycardBvertexnumber[1];
5978 ycardBvertexnumber[10] = ycardBvertexnumber[9];
5979 ycardBvertexnumber[11] = ycardBvertexnumber[0];
5980
5981 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5982 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5983 interfacecardBshape->DefineSection(0,0.);
5984 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5985 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5986 fSSDMountingBlockMedium);
5987 interfacecardB->SetLineColor(46);
5988 // Interface Card B Electronic Board
5989 const Int_t kelectboardcardBvertexnumber = 14;
5990 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5991 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5992
5993 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5994 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
5995 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
5996 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
5997 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
5998 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
5999 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
6000 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
6001 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
6002 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
6003 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
6004 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
6005 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
6006 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
6007
6008 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
6009 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
6010 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
6011 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
6012 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
6013 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
6014 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
6015 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
6016 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
6017 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
6018 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
6019 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
6020 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
6021 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
6022
6023 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
6024 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
6025 xelectboardcardBvertex,yelectboardcardBvertex);
6026 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
6027 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
6028 + fgkEndCapInterfaceElectBoardCardBThickness);
6029 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
6030 fSSDSupportRingAl);
6031 electboardcardB->SetLineColor(fColorAl);
6032 // Generating Stiffener 2
6033 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
6034 0.5*fgkEndCapStiffenerThickness,
6035 0.5*fgkEndCapStiffenerLength);
6036 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
6037 endcapstiffener->SetLineColor(fColorAl);
6038 // Generating Mother Interface Card B Container
6039 const Int_t kinterfacecardBmothervertexnumber = 10;
6040 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6041 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
6042
6043 xinterfacecardBmothervertex[0] = 0.0;
6044 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
6045 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
6046 + fgkEndCapInterfaceCardBThickness;
6047 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
6048 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
6049 + fgkEndCapInterfaceElectBoardCardBThickness;
6050 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
6051 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
6052 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
6053 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
6054 + fgkEndCapCardJMDConnectorLength[0];
6055 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
6056
6057 yinterfacecardBmothervertex[0] = 0.0;
6058 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
6059 + fgkEndCapInterfaceCardBWidth[1]
6060 + fgkEndCapInterfaceCardBWidth[2];
6061 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
6062 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
6063 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
6064 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
6065 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6066 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6067 + fgkEndCapCardJMDConnectorWidth[0]
6068 + fgkEndCapCardJMDConnectorWidth[1];
6069 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6070 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6071 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6072 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6073 xinterfacecardBmothervertex,
6074 yinterfacecardBmothervertex);
6075 interfacecardBmothershape->DefineSection(0,-1.e-15);
6076 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6077 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6078 interfacecardBmothershape,fSSDAir);
6079 electboardcardB->SetLineColor(fColorAl);
6080 // Positioning Volumes Mother Interface Card B Container
6081 TGeoRotation* interfacecardBrot = new TGeoRotation();
6082 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6083 interfacecardBrot->SetAngles(90.,-90.,-90.);
6084 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6085 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6086 TGeoRotation* electboardcardBrot = new TGeoRotation();
6087 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6088 electboardcardBrot->SetAngles(90.,90.,-90.);
6089 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6090 TGeoCombiTrans* electboardcardBcombitrans =
6091 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6092 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6093 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6094 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6095 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6096 TGeoTranslation* jmdconnectorcardBtrans[3];
6097 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6098 for(Int_t i=0; i<3; i++){
6099 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6100 + fgkEndCapCardJMDConnectorLength[0],
6101 fgkEndCapCardElectBoardLayerWidth[1],
6102 0.5*fgkEndCapCardJMDConnectorThickness
6103 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6104 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6105 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6106 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6107 *jmdconnectorcardBrot);
6108 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6109 }
6110 // Mother Supply Card Container
6111 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6112 // Interface Card Container
6113 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6114 // Placing Volumes in Mother Supply Card Container
6115 // JMD Connector Positioning
6116 TGeoTranslation* jmdconnectortrans[2];
6117 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6118 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6119 fgkEndCapCardElectBoardBackLength[0]
6120 - fgkEndCapCardJMDConnectorThickness
6121 - fgkEndCapCardJMDConnectorToLayer);
6122 TGeoRotation* jmdconnectorot = new TGeoRotation();
6123 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6124 + 2.*fgkEndCapCardJMDConnectorLength[0]
6125 + 2.*fgkEndCapCardElectBoardLayerThickness,
6126 fgkEndCapCardElectBoardLayerWidth[1],
6127 fgkEndCapCardJMDConnectorThickness
6128 + fgkEndCapCardJMDConnectorToLayer);
6129 jmdconnectorot->SetAngles(90.,180.,-90);
6130 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6131 * jmdconnectorot);
6132 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6133 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6134 // Top Cable Connector Placing
6135 TGeoRotation* cableconnectorot[2];
6136 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6137 TGeoTranslation* cableconnectortrans[3];
6138 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6139 cableconnectorot[0]->SetAngles(90.,0.,0.);
6140 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6141 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6142 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6143 *cableconnectorot[0]);
6144 TGeoHMatrix* cableconnectormatrix[2];
6145 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6146 new TGeoHMatrix((*cableconnectorot[1])
6147 *(*cableconnectorcombitrans));
6148 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6149 - fgkEndCapCardCableConnectorThickness,
6150 fgkEndCapCardCableConnectorLength[0]
6151 + fgkEndCapCardCableConnectorToLayer);
6152 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6153 - 2.*fgkEndCapCardCableConnectorThickness
6154 - fgkEndCapCardCableConnectorDistance,
6155 fgkEndCapCardCableConnectorLength[0]
6156 + fgkEndCapCardCableConnectorToLayer);
6157 for(Int_t i=0; i<2; i++){
6158 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6159 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6160 }
6161 TGeoRotation* electboardbackrot = new TGeoRotation();
6162 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6163 electboardbackrot->SetAngles(90.,-90.,-90.);
6164 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6165 + fgkEndCapCardJMDConnectorLength[0]
6166 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6167 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6168 *electboardbackrot);
6169 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6170 // Electronic Board Kapton Layer Positioning
6171 TGeoRotation* electlayerrot = new TGeoRotation();
6172 TGeoTranslation* electlayertrans[2];
6173 TGeoCombiTrans* electlayercombitrans[2];
6174 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6175 electlayerrot->SetAngles(90.,-90.,-90.);
6176 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6177 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6178 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6179 + 2.*fgkEndCapCardElectBoardLayerThickness
6180 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6181 for(Int_t i=0; i<2; i++){
6182 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6183 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6184 }
6185 // Placing Volumes in Mother Interface Card Container
6186 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6187 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6188 for(Int_t i=0; i<2; i++){
6189 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6190 }
6191 /////////////////////////////////////////////////////////////
6192 // Generation of Card Interface Container
6193 /////////////////////////////////////////////////////////////
6194 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6195 - fgkEndCapCardJMDConnectorLength[0]
6196 - fgkEndCapInterfaceCardBThickness
6197 - 9.*fgkEndCapStripConnectionThickness
6198 - 8.*fgkEndCapCardElectBoardBackThickness;
6199 const Int_t kcardinterfacecontainervertexnumber = 14;
6200 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6201 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6202 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6203 - 7.0*fgkEndCapStripConnectionThickness;
6204 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6205 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6206 + fgkEndCapStripConnectionThickness
6207 - fgkEndCapCardElectBoardLayerThickness
6208 - fgkEndCapCardCableConnectorWidth[0];
6209 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6210 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6211 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6212 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6213 + 2.0*fgkEndCapStripConnectionThickness;
6214 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6215 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6216 + fgkEndCapInterfaceCardBThickness;
6217 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6218 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6219 + fgkEndCapInterfaceElectBoardCardBThickness;
6220 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6221 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6222 - fgkEndCapInterfaceElectBoardCardBThickness
6223 + fgkEndCapCardJMDConnectorLength[0]
6224 + stiffenertransx+fgkEndCapStiffenerWidth;
6225 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6226
6227 ycardinterfacecontainervertex[0] = 0.;
6228 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6229 + fgkEndCapCardJMDConnectorWidth[0]
6230 + fgkEndCapCardJMDConnectorWidth[1];
6231 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6232 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6233 - fgkEndCapStripConnectionWidth;
6234 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6235 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6236 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6237 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6238 + fgkEndCapInterfaceCardBWidth[1]
6239 + fgkEndCapInterfaceCardBWidth[2];
6240 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6241 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6242 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6243 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6244 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6245 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6246
6247 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6248 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6249 xcardinterfacecontainervertex,
6250 ycardinterfacecontainervertex);
6251 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6252 - fgkEndCapCardElectBoardBackLength[0]));
6253 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6254 + fgkEndCapCardElectBoardBackLength[0]));
6255 TGeoVolume** cardinterfacecontainer;
6256 cardinterfacecontainer = new TGeoVolume*[4];
6257 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6258 interfacecardmothershape,fSSDAir);
6259 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6260 interfacecardmothershape,fSSDAir);
6261 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6262 interfacecardmothershape,fSSDAir);
6263 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6264 interfacecardmothershape,fSSDAir);
6265 /////////////////////////////////
6266 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6267 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6268 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6269 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6270 /////////////////////////////////
6271 TGeoRotation* endcapstripconnectionrot[2];
6272 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6273 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6274 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6275 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6276 * (*endcapstripconnectionrot[0]));
6277 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6278 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6279 -0.5*fgkEndCapCardElectBoardBackThickness,
6280 fgkEndCapCardElectBoardBackWidth[0]
6281 -endcapstripconnectionshape->GetDZ(),
6282 0.5*fgkEndCapCardElectBoardBackLength[0]);
6283 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6284 TGeoTranslation* cardinterfacetrans[9];
6285 TGeoHMatrix* cardinterfacematrix[9];
6286 for(Int_t i=0; i<7; i++){
6287 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6288 + fgkEndCapCardElectBoardBackThickness),
6289 0.0,0.0);
6290 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6291 * (*endcapstripconnectionmatrix));
6292 }
6293 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6294 + fgkEndCapCardElectBoardBackThickness),
6295 0.0,0.0);
6296 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6297 * (*endcapstripconnectionmatrix));
6298 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6299 + fgkEndCapCardElectBoardBackThickness),
6300 0.0,0.0);
6301 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6302 * (*endcapstripconnectionmatrix));
6303
6304 for(Int_t i=0; i<4; i++){
6305 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6306 cardinterfacematrix[7]);
6307 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6308 cardinterfacematrix[8]);
6309 }
6310 TGeoTranslation* mothersupplycardtrans =
6311 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6312 + 2.*fgkEndCapCardJMDConnectorLength[0]
6313 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6314 TGeoHMatrix* mothersupplycardmatrix[7];
6315 Int_t index[4] = {1,1,1,1};
6316 for(Int_t i=0; i<7; i++){
6317 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6318 * (*mothersupplycardtrans));
6319 for(Int_t j=0; j<4; j++){
6320 switch(j){
6321 case 0: //Layer5 EndCap Left Side
6322 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6323 cardinterfacematrix[i]);
6324 if(i!=0){
6325 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6326 mothersupplycardmatrix[i]);
6327 index[j]++;
6328
6329 }
6330 break;
6331 case 1: //Layer5 EndCap Rigth Side
6332 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6333 cardinterfacematrix[i]);
6334 if(i>0&&i<6){
6335 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6336 mothersupplycardmatrix[i]);
6337 index[j]++;
6338 }
6339 break;
6340 case 2: //Layer6 EndCap Left Side
6341 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6342 cardinterfacematrix[i]);
6343 if(i!=6){
6344 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6345 mothersupplycardmatrix[i]);
6346 index[j]++;
6347 }
6348 break;
6349 case 3: //Layer6 EndCap Right Side
6350 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6351 cardinterfacematrix[i]);
6352 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6353 mothersupplycardmatrix[i]);
6354 index[j]++;
6355 break;
6356 }
6357 }
6358 }
6359 // Positioning Interface
6360 TGeoTranslation* motherinterfacecardtrans =
6361 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6362 +0.5*fgkEndCapCardElectBoardBackThickness
6363 -fgkEndCapCardElectBoardLayerThickness
6364 +fgkEndCapStripConnectionThickness,0.,0.);
6365 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6366 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6367 // Positioning Interface Card B
6368 TGeoTranslation* interfacecardBmothertrans =
6369 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6370 + 2.*fgkEndCapStripConnectionThickness
6371 + fgkEndCapCardElectBoardBackThickness,0.,
6372 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6373 - fgkEndCapCardElectBoardBackLength[0]));
6374 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6375 interfacecardBmothertrans);
6376 // Positioning Stiffener
6377 TGeoTranslation* endcapstiffenertrans =
6378 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6379 + 2.0*fgkEndCapStripConnectionThickness
6380 + fgkEndCapInterfaceCardBThickness
6381 + fgkEndCapCardJMDConnectorLength[0]
6382 + stiffenertransx
6383 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6384 endcapstiffenershape->GetDZ()
6385 - 0.5*(fgkEndCapStiffenerLength
6386 - fgkEndCapCardElectBoardBackLength[0]));
6387 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6388 /////////////////////////////////////////////////////////////
6389 // Deallocating memory
6390 /////////////////////////////////////////////////////////////
6391 delete interfacecardBrot;
6392 delete interfacecardBtrans;
6393 delete electboardcardBtrans;
6394 delete electboardcardBrot;
6395 delete jmdconnectorcardBrot;
6396 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6397 delete jmdconnectorot;
6398 delete jmdconnectortrans[1];
6399 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6400 delete cableconnectorcombitrans;
6401 delete electboardbacktrans;
6402 delete electboardbackrot;
6403 delete electlayerrot;
6404 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6405 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6406 delete mothersupplycardtrans;
6407 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6408 /////////////////////////////////////////////////////////////
6409 return cardinterfacecontainer;
6410 }
6411 ////////////////////////////////////////////////////////////////////////////////
6412 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6413 /////////////////////////////////////////////////////////////
6414 // Method returning EndCap Mother Volume
6415 /////////////////////////////////////////////////////////////
6416 const Int_t kendcapcoverplatesmallholenumber = 9;
6417 Double_t endcapmotherorigin[3];
6418 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6419 + 0.5 *(fgkEndCapCoverPlateLength[3]
6420 + 2.0 * fgkEndCapCoverPlateLength[2]);
6421 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6422 - fgkEndCapCoverPlateWidth[2]
6423 - (kendcapcoverplatesmallholenumber-1)
6424 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6425 + 0.5*(fgkEndCapSideCoverLength[2]
6426 + fgkEndCapCoverPlateWidth[1]
6427 - fgkEndCapCoverPlateWidth[0])
6428 - (fgkEndCapCoverPlateWidth[1]
6429 - fgkEndCapCoverPlateWidth[0]);
6430 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6431 + 2.*fgkEndCapCoolingTubeRadiusMax
6432 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6433 + fgkEndCapSideCoverWidth[1]
6434 + fgkEndCapSideCoverThickness
6435 + fgkEndCapKaptonFoilThickness);
6436 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6437 + 2.0* fgkEndCapCoverPlateLength[2]
6438 + 2.0* fgkEndCapSideCoverThickness),
6439 0.5* (fgkEndCapSideCoverLength[2]
6440 + fgkEndCapCoverPlateWidth[1]
6441 - fgkEndCapCoverPlateWidth[0]),
6442 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6443 + fgkEndCapSideCoverWidth[1]
6444 + fgkEndCapSideCoverThickness
6445 + fgkEndCapKaptonFoilThickness),
6446 endcapmotherorigin);
6447 TGeoVolume** endcapassembly;
6448 endcapassembly = new TGeoVolume*[4];
6449 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6450 endcapmothershape,fSSDAir);
6451 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6452 endcapmothershape,fSSDAir);
6453 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6454 endcapmothershape,fSSDAir);
6455 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6456 endcapmothershape,fSSDAir);
6457 /////////////////////////////////
6458 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6459 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6460 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6461 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6462 /////////////////////////////////
6463 /////////////////////////////////////////////////////
6464 // Placing Endcap Cover Plate
6465 /////////////////////////////////////////////////////
6466 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6467 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6468 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6469 TGeoCombiTrans* endcapcoverplatecombitrans =
6470 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6471 endcapcoverplaterot);
6472 TGeoTranslation* endcapcoverplatetrans =
6473 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6474 TGeoHMatrix* endcapcoverplatematrix =
6475 new TGeoHMatrix((*endcapcoverplatetrans)
6476 * (*endcapcoverplatecombitrans));
6477 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6478 /////////////////////////////////////////////////////
6479 // Placing Endcap Side Cover
6480 /////////////////////////////////////////////////////
6481 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6482 TGeoRotation* endcapsidecoverot[2];
6483 TGeoCombiTrans* endcapsidecovercombitrans[3];
6484 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6485 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6486 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6487 - 0.5*(fgkEndCapCoverPlateWidth[0]
6488 - fgkEndCapCoverPlateWidth[2]
6489 - (kendcapcoverplatesmallholenumber-1)
6490 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6491 + 0.*fgkEndCapCoverPlateWidth[0]
6492 + fgkEndCapSideCoverLength[2],
6493 0.5*(fgkEndCapSideCoverThickness
6494 + fgkEndCapCoverPlateThickness)
6495 - 0.5*fgkEndCapCoverPlateThickness,
6496 endcapsidecoverot[0]);
6497 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6498 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6499 0.5*fgkEndCapCoverPlateThickness
6500 -fgkEndCapSideCoverWidth[1],
6501 endcapsidecoverot[1]);
6502 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6503 +fgkEndCapCoverPlateLength[3]
6504 +2.*fgkEndCapCoverPlateLength[2]
6505 +fgkEndCapSideCoverThickness,0.0,
6506 0.5*fgkEndCapCoverPlateThickness
6507 -fgkEndCapSideCoverWidth[1],
6508 endcapsidecoverot[1]);
6509 TGeoHMatrix* endcapsidecovermatrix[2];
6510 for(Int_t i=0; i<2; i++){
6511 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6512 * (*endcapsidecovercombitrans[0]));
6513 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6514 endcapsidecovermatrix[i]);
6515 }
6516 /////////////////////////////////////////////////////
6517 // Placing Endcap Cooling Tube
6518 /////////////////////////////////////////////////////
6519 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6520 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6521 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6522 TGeoCombiTrans* endcapccolingtubecombitrans
6523 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6524 + fgkEndCapCoolingTubeAxialRadius[1])
6525 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6526 - fgkEndCapCoolingTubeToCoverSide,
6527 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6528 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6529 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6530 endcapccolingtubecombitrans);
6531 /////////////////////////////////////////////////////
6532 // Placing Screws
6533 /////////////////////////////////////////////////////
6534 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6535 fgkEndCapCoverPlateScrewRadiusMin};
6536 Int_t screwcoverplatedgesnumber[2] = {20,20};
6537 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6538 fgkEndCapCoverPlateThickness
6539 + fgkEndCapCoolingTubeRadiusMax};
851c0ce3 6540 TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
9b0c60ab 6541 screwcoverplatedgesnumber,
6542 screwcoverplatesection);
6543 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6544 screwcoverplateshape,
6545 fSSDCoolingTubePhynox);
6546 screwcoverplate->SetLineColor(12);
6547 Double_t transx[4] = {0,
6548 fgkEndCapCoverPlateSmallHoleSeparation[0],
6549 fgkEndCapCoverPlateSmallHoleSeparation[0]
6550 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6551 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6552 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6553 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6554// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6555 TGeoTranslation*** endcapcoverplatescrewtrans;
6556 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6557 Int_t index = 0;
6558 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6559 endcapcoverplatescrewtrans[i] =
6560 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6561 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6562 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6563 if(index==1||index==9||index==28||index==36){
6564 endcapcoverplatescrewtrans[i][j] =
6565 new TGeoTranslation(transx[i],
6566 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6567 fgkEndCapSideCoverThickness);
6568 }
6569 else{
6570 endcapcoverplatescrewtrans[i][j] =
6571 new TGeoTranslation(transx[i],
6572 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6573 0.);
6574 }
6575 if(index!=19)
6576 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6577 endcapcoverplatescrewtrans[i][j]);
6578 }
6579 }
6580 /////////////////////////////////////////////////////
6581 // Placing Cover Plate Clips
6582 /////////////////////////////////////////////////////
6583 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6584 0.5*fgkEndCapCoverPlateClipWidth,
6585 0.5*fgkEndCapSideCoverThickness);
6586 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6587 endcapcoverplateclipshape,
6588 fSSDCoolingTubePhynox);
6589 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6590 0.5*fgkEndCapCoverPlateDownClipWidth,
6591 0.5*fgkEndCapSideCoverThickness);
6592 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6593 endcapcoverplatedownclipshape,
6594 fSSDCoolingTubePhynox);
6595 TGeoTranslation* endcapcoverplatecliptrans[4];
6596 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6597 - fgkEndCapCoverPlateLength[0]
6598 - fgkEndCapSideCoverThickness,
6599 0.0,
6600 0.5*(fgkEndCapSideCoverThickness
6601 + fgkEndCapCoverPlateThickness));
6602 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6603 - fgkEndCapCoverPlateLength[0]
6604 - fgkEndCapSideCoverThickness,
6605 (kendcapcoverplatescrewnumber[1]-1)
6606 * fgkEndCapSideCoverWidth[5],
6607 0.5*(fgkEndCapSideCoverThickness
6608 + fgkEndCapCoverPlateThickness));
6609 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6610 - fgkEndCapCoverPlateLength[0]
6611 + fgkEndCapCoverPlateLength[1]
6612 + 2.*fgkEndCapCoverPlateLength[0]
6613 - fgkEndCapCoverPlateClipLength
6614 + fgkEndCapSideCoverThickness,
6615 0.0,
6616 0.5*(fgkEndCapSideCoverThickness
6617 + fgkEndCapCoverPlateThickness));
6618 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6619 - fgkEndCapCoverPlateLength[0]
6620 + fgkEndCapCoverPlateLength[1]
6621 + 2.*fgkEndCapCoverPlateLength[0]
6622 - fgkEndCapCoverPlateClipLength
6623 + fgkEndCapSideCoverThickness,
6624 (kendcapcoverplatescrewnumber[1]-1)
6625 * fgkEndCapSideCoverWidth[5],
6626 0.5*(fgkEndCapSideCoverThickness
6627 + fgkEndCapCoverPlateThickness));
6628 endcapcoverplateclip->SetLineColor(fColorPhynox);
6629 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6630 for(Int_t i=0; i<4; i++)
6631 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6632 endcapcoverplatecliptrans[i]);
6633 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6634 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6635 - fgkEndCapCoverPlateLength[0]
6636 - fgkEndCapSideCoverThickness,
6637 0.5*(fgkEndCapCoverPlateDownClipWidth
6638 - fgkEndCapCoverPlateClipWidth),
6639 0.5*(fgkEndCapSideCoverThickness
6640 + fgkEndCapCoverPlateThickness)
6641 - fgkEndCapSideCoverWidth[1]
6642 - fgkEndCapSideCoverThickness);
6643 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6644 - fgkEndCapCoverPlateLength[0]
6645 - fgkEndCapSideCoverThickness,
6646 0.5*(fgkEndCapCoverPlateDownClipWidth
6647 - fgkEndCapCoverPlateClipWidth)
6648 + fgkEndCapSideCoverLength[2]
6649 - fgkEndCapCoverPlateDownClipWidth,
6650 0.5*(fgkEndCapSideCoverThickness
6651 + fgkEndCapCoverPlateThickness)
6652 - fgkEndCapSideCoverWidth[1]
6653 - fgkEndCapSideCoverThickness);
6654 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6655 - fgkEndCapCoverPlateLength[0]
6656 + fgkEndCapSideCoverThickness
6657 + fgkEndCapCoverPlateLength[1]
6658 + 2.0*fgkEndCapCoverPlateLength[0]
6659 - fgkEndCapCoverPlateDownClipLength,
6660 0.5*(fgkEndCapCoverPlateDownClipWidth
6661 - fgkEndCapCoverPlateClipWidth),
6662 0.5*(fgkEndCapSideCoverThickness
6663 + fgkEndCapCoverPlateThickness)
6664 - fgkEndCapSideCoverWidth[1]
6665 - fgkEndCapSideCoverThickness);
6666 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6667 - fgkEndCapCoverPlateLength[0]
6668 + fgkEndCapSideCoverThickness
6669 + fgkEndCapCoverPlateLength[1]
6670 + 2.0*fgkEndCapCoverPlateLength[0]
6671 - fgkEndCapCoverPlateDownClipLength,
6672 0.5*(fgkEndCapCoverPlateDownClipWidth
6673 - fgkEndCapCoverPlateClipWidth)
6674 + fgkEndCapSideCoverLength[2]
6675 - fgkEndCapCoverPlateDownClipWidth,
6676 0.5*(fgkEndCapSideCoverThickness
6677 + fgkEndCapCoverPlateThickness)
6678 - fgkEndCapSideCoverWidth[1]
6679 - fgkEndCapSideCoverThickness);
6680 for(Int_t i=0; i<4; i++)
6681 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6682 endcapcoverplatedowncliptrans[i]);
6683 /////////////////////////////////////////////////////
6684 // Placing Kapton Foil
6685 /////////////////////////////////////////////////////
6686 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6687 0.5*fgkEndCapKaptonFoilWidth,
6688 0.5*fgkEndCapKaptonFoilThickness);
6689 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6690 endcapkaptonfoilshape,
6691 fSSDKaptonFlexMedium);
6692 endcapkaptonfoil->SetLineColor(8);
6693 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6694 0.5*fgkEndCapKaptonFoilWidth
6695 - 0.5*fgkEndCapCoverPlateClipWidth,
6696 0.5*fgkEndCapCoverPlateThickness
6697 - 0.5*fgkEndCapKaptonFoilThickness
6698 - fgkEndCapSideCoverWidth[1]
6699 - fgkEndCapSideCoverThickness);
6700 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6701 /////////////////////////////////////////////////////////////
6702 // Placing Electronic Tubes
6703 /////////////////////////////////////////////////////////////
6704 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6705 - fgkEndCapInterfaceCardBThickness
6706 - 9.*fgkEndCapStripConnectionThickness
6707 - 8.*fgkEndCapCardElectBoardBackThickness,
6708 fgkEndCapKaptonFoilWidth
6709 - fgkEndCapInterfaceCardBThickness
6710 - 9.*fgkEndCapStripConnectionThickness
6711 - 8.*fgkEndCapCardElectBoardBackThickness
6712 - fgkEndCapInterfaceElectBoardCardBThickness};
6713 TGeoVolume* endcapeffectivecables[2];
6714 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6715 fgkEndCapEffectiveCableRadiusMax,
6716 endcapeffectivecableswidth[0],
6717 10,"EndCapEffectiveCables1");
6718 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6719 fgkEndCapEffectiveCableRadiusMax,
6720 endcapeffectivecableswidth[1],
6721 25,"EndCapEffectiveCables2");
6722 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6723 TGeoTranslation* endcapeffectivecablestrans[2];
6724 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6725 - 0.5*endcapeffectivecableswidth[0]
6726 - 0.5*(fgkEndCapCoverPlateWidth[0]
6727 - fgkEndCapCoverPlateWidth[2]
6728 - (kendcapcoverplatesmallholenumber-1)
6729 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6730 + fgkEndCapSideCoverLength[2],
6731 - 0.5*fgkEndCapCoverPlateThickness
6732 - (fgkEndCapCardElectBoardBackWidth[0]
6733 - fgkEndCapInterfaceCardBWidth[0]
6734 - fgkEndCapInterfaceCardBWidth[1]));
6735 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6736 - 0.5*endcapeffectivecableswidth[1]
6737 - 0.5*(fgkEndCapCoverPlateWidth[0]
6738 - fgkEndCapCoverPlateWidth[2]
6739 - (kendcapcoverplatesmallholenumber-1)
6740 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6741 + fgkEndCapSideCoverLength[2],
6742 - 0.5*fgkEndCapCoverPlateThickness
6743 - (fgkEndCapCardElectBoardBackWidth[0]
6744 - fgkEndCapInterfaceCardBWidth[0])
6745 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6746 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6747 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6748 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6749 *endcapeffectivecablesrot);
6750 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6751 *endcapeffectivecablesrot);
47f8de53 6752// for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6753// endcapeffectivecablescombitrans[0]);
9b0c60ab 6754 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6755 endcapeffectivecablescombitrans[1]);
6756 /////////////////////////////////////////////////////////////
6757 // Placing End Cap Cards
6758 /////////////////////////////////////////////////////////////
6759 TGeoVolume** endcapcards = GetEndCapCards();
6760 TGeoRotation* endcapcardsrot[2];
6761 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6762 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6763 TGeoTranslation* endcapcardstrans[2];
6764 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6765 - fgkEndCapCardElectBoardBackLength[0]));
6766 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6767 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6768 TGeoHMatrix* endcapcardsmatrix[2];
6769 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6770 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6771 - fgkEndCapCardJMDConnectorLength[0]
6772 - fgkEndCapInterfaceCardBThickness
6773 - 9.*fgkEndCapStripConnectionThickness
6774 - 8.*fgkEndCapCardElectBoardBackThickness;
6775 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6776 - fgkEndCapCoverPlateLength[0]
6777 + 0.5 * (fgkEndCapCoverPlateLength[3]
6778 + 2.0 * fgkEndCapCoverPlateLength[2]),
6779 - stiffenertransx-fgkEndCapStiffenerWidth
6780 - fgkEndCapCardJMDConnectorLength[0]
6781 - fgkEndCapInterfaceCardBThickness
6782 - 2.0 * fgkEndCapStripConnectionThickness
6783 - 1.5 * fgkEndCapInterfaceCardBThickness
6784 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6785 - fgkEndCapCoverPlateWidth[2]
6786 - (kendcapcoverplatesmallholenumber-1)
6787 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6788 + fgkEndCapKaptonFoilWidth,
6789 0.5*fgkEndCapCoverPlateThickness
6790 - fgkEndCapSideCoverWidth[1]);
6791 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6792 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6793 /////////////////////////////////////////////////////////////
6794 // Deallocating memory
6795 /////////////////////////////////////////////////////////////
6796 delete endcapcoverplaterot;
6797 delete endcapcoverplatecombitrans;
6798 delete endcapcoverplatetrans;
6799 for(Int_t i=0; i<3; i++){
6800 delete endcapsidecovercombitrans[i];
6801 if(i<2) delete endcapsidecoverot[i];
6802 }
6803 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6804 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6805 delete endcapcardsmatrix[0];
6806 return endcapassembly;
6807 }
6808 ////////////////////////////////////////////////////////////////////////////////
6809 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6810 Double_t radiusmax,
6811 Double_t width,
6812 Int_t ncables,
a6e0ebfe 6813 const char* volname){
9b0c60ab 6814 /////////////////////////////////////////////////////////////
6815 // Generating EndCap High Voltage Tubes
6816 /////////////////////////////////////////////////////////////
6817 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
60e55aee 6818 Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6819
9b0c60ab 6820 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6821 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6822 effectiveouteradius,0.5*width);
6823 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6824 effectiveinnertubeshape,
6825 fSSDStiffenerConnectorMedium);
6826 effectiveinnertube->SetLineColor(41);
6827 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6828 effectiveoutertubeshape,
6829 fSSDKaptonChipCableMedium);
6830 effectiveoutertube->SetLineColor(39);
6831 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6832 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6833 effectivemothertube->AddNode(effectiveinnertube,1);
6834 effectivemothertube->AddNode(effectiveoutertube,1);
6835 return effectivemothertube;
6836 }
6837 ////////////////////////////////////////////////////////////////////////////////
6838 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6839 /////////////////////////////////////////////////////////////
6840 // Generating EndCap Support Layer 5 and Layer 6
6841 /////////////////////////////////////////////////////////////
6842 const Int_t knedges = 5;
6843 ///////////////////////////////////////////////
6844 // Setting the vertices for TGeoXtru Up Volume
6845 ///////////////////////////////////////////////
6846 const Int_t klayernumber = 2;
6847 Double_t xupvertex[klayernumber][knedges+3];
6848 Double_t yupvertex[klayernumber][knedges+3];
6849 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6850 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6851 Double_t middlepsi[klayernumber] = {0.0,0.0};
6852 for(Int_t i=0; i<klayernumber; i++){
6853 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6854 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6855 xupvertex[i][2] = -xupvertex[i][1];
6856 xupvertex[i][3] = -xupvertex[i][0];
6857
6858 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6859 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6860 yupvertex[i][2] = yupvertex[i][1];
6861 yupvertex[i][3] = yupvertex[i][0];
6862
6863 middledgeangle[i] = upedgeangle[i]/knedges;
6864 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6865 for(Int_t j=1; j<knedges; j++){
6866 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6867 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6868 }
6869 }
6870 ////////////////////////////////////
6871 // Generating Up TGeoXtru
6872 ////////////////////////////////////
6873 TGeoXtru* upendcapsupportshape[klayernumber];
6874 TGeoVolume* upendcapsupport[klayernumber];
a3f8715e 6875 char upendcapsupportname[100];
9b0c60ab 6876 for(Int_t i=0; i<klayernumber; i++){
6877 upendcapsupportshape[i] = new TGeoXtru(2);
045be90c 6878 snprintf(upendcapsupportname,100,"UpEndCapSupportPieceLayer%i",i+5);
9b0c60ab 6879 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6880 upendcapsupportshape[i]->DefineSection(0,0.);
6881 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6882 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 6883 fSSDSupportRingAl);
9b0c60ab 6884 upendcapsupport[i]->SetLineColor(5);
6885 }
6886 ///////////////////////////////////////////////
6887 // Setting the vertices for TGeoXtru Down Volume
6888 ///////////////////////////////////////////////
6889 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6890 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6891 for(Int_t i=0; i<klayernumber; i++){
6892 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6893 xdownvertex[i][1] = xupvertex[i][0];
6894 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6895 ydownvertex[i][1] = yupvertex[i][0];
6896 for(Int_t j=0; j<knedges; j++){
6897 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6898 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6899 }
6900 for(Int_t j=0; j<knedges; j++){
6901 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6902 * CosD(middlepsi[i]+j*middledgeangle[i]);
6903 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6904 * SinD(middlepsi[i]+j*middledgeangle[i]);
6905 }
6906 }
6907 ////////////////////////////////////
6908 // Generating Down TGeoXtru
6909 ////////////////////////////////////
6910 TGeoXtru* downendcapsupportshape[klayernumber];
6911 TGeoVolume* downendcapsupport[klayernumber];
a3f8715e 6912 char downendcapsupportname[100];
9b0c60ab 6913 for(Int_t i=0; i<klayernumber; i++){
6914 downendcapsupportshape[i] = new TGeoXtru(2);
045be90c 6915 snprintf(downendcapsupportname,100,"DownEndCapSupportPieceLayer%i",i+5);
9b0c60ab 6916 downendcapsupportshape[i] = new TGeoXtru(2);
6917 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6918 if(i==0){
6919 downendcapsupportshape[i]->DefineSection(0,0.);
6920 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6921 }
6922 else{
6923 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6924 - fgkEndCapSupportLowWidth[i]);
6925 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6926 }
6927 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 6928 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 6929 downendcapsupport[i]->SetLineColor(5);
6930 }
6931 ///////////////////////////////////////////////
6932 // Setting TGeoPgon Volume
6933 ///////////////////////////////////////////////
6934 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6935 fgkSSDLay6LadderNumber};
6936 TGeoPgon* endcapsupportmothershape[klayernumber];
6937 TGeoVolume** endcapsupportmother;
6938 endcapsupportmother = new TGeoVolume*[klayernumber];
a3f8715e 6939 char endcapsupportmothername[100];
9b0c60ab 6940 for(Int_t i=0; i<klayernumber; i++){
6941 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
045be90c 6942 snprintf(endcapsupportmothername,100,"EndCapSupportMotherLayer%i",i+5);
9b0c60ab 6943 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6944 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6945 ydownvertex[i][0],yupvertex[i][1]);
6946 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 6947 fSSDAir);
9b0c60ab 6948 }
6949 ////////////////////////////////////
6950 TGeoRotation** endcapsupportrot[klayernumber];
6951 for(Int_t i=0; i<2; i++){
6952 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6953 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6954 endcapsupportrot[i][j] = new TGeoRotation();
6955 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6956 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6957 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6958 }
6959 }
6960 return endcapsupportmother;
6961 }
6962 ////////////////////////////////////////////////////////////////////////////////
6963 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6964 /////////////////////////////////////////////////////////////
6965 // Setting End Cap Support Layer 5 and 6.
6966 /////////////////////////////////////////////////////////////
6967 const Int_t kendcapcoverplatesmallholenumber = 9;
6968 const Int_t klayernumber = 2;
6969 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6970 fgkSSDLay6LadderNumber};
6971 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6972 360.0/kssdlayladdernumber[1]};
6973 TGeoVolume** endcapsupport = EndCapSupport();
6974 TGeoVolume** endcapassembly = GetEndCapAssembly();
6975 TGeoPgon* endcapsupportshape[klayernumber];
6976 Double_t* radiusmin[klayernumber];
6977 Double_t* radiusmax[klayernumber];
6978 for(Int_t i=0; i<klayernumber; i++){
6979 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6980 radiusmin[i] = endcapsupportshape[i]->GetRmin();
6981 radiusmax[i] = endcapsupportshape[i]->GetRmax();
6982 }
6983 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6984 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6985 endcapassemblyshape->GetDY(),
6986 endcapassemblyshape->GetDZ()};
6987 ///////////////////////////////////////////////
6988 // Setting TGeoPgon Volume for Mother Container
6989 ///////////////////////////////////////////////
6990 TGeoPgon* endcapsupportsystemshape[klayernumber];
a3f8715e 6991 char endcapsupportsystemothername[100];
9b0c60ab 6992 for(Int_t i=0; i<klayernumber; i++){
6993 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
045be90c 6994 snprintf(endcapsupportsystemothername,100,"EndCapSupportSystemLayer%i",i+5);
9b0c60ab 6995 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
6996 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
6997 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6998 +2.*endcapassemblycenter[2])
6999 /CosD(0.5*upedgeangle[i]));
7000 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
7001 -(fgkEndCapCoverPlateWidth[1]
7002 - fgkEndCapCoverPlateWidth[0]),
7003 *radiusmin[i],
7004 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
7005 +2.*endcapassemblycenter[2])
7006 /CosD(0.5*upedgeangle[i]));
7007 }
e5bf64ae 7008 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 7009 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
7010 endcapsupportsystemshape[0],fSSDAir);
7011 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
7012 endcapsupportsystemshape[0],fSSDAir);
7013 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
7014 endcapsupportsystemshape[1],fSSDAir);
7015 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
7016 endcapsupportsystemshape[1],fSSDAir);
7017 ///////////////////////////////////////////////
7018 TGeoTranslation* endcapassemblytrans[klayernumber];
7019 for(Int_t i=0; i<klayernumber; i++)
7020 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
7021 - fgkEndCapSideCoverThickness
7022 + endcapassemblycenter[0],
7023 - 0.5*fgkEndCapCoverPlateThickness
7024 - 2.0*fgkEndCapCoolingTubeRadiusMax
7025 + 2.0*endcapassemblycenter[2]
7026 + 0.5*fgkEndCapSupportLength[i]
7027 / TanD(0.5*upedgeangle[i]),
7028 0.5*(fgkEndCapCoverPlateWidth[0]
7029 - fgkEndCapCoverPlateWidth[2]
7030 - (kendcapcoverplatesmallholenumber-1)
7031 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
7032 TGeoRotation** endcapassemblyrot[klayernumber];
7033 TGeoHMatrix** endcapassemblymatrix[klayernumber];
7034 for(Int_t i=0; i<klayernumber; i++){
7035 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
7036 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
7037 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
7038 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
7039 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
7040 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
7041 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
7042 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
7043 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
7044 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
7045 }
7046 }
7047 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
7048 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
7049 for(Int_t i=0; i<2*klayernumber; i++){
7050 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
7051 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
7052 endcapassemblymatrix[1][j+2]);
7053 }
7054 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
7055 }
7056 /////////////////////////////////////////////////////////////
7057 // Deallocating memory
7058 /////////////////////////////////////////////////////////////
7059 for(Int_t i=0; i<klayernumber; i++){
7060 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
7061 delete endcapassemblyrot[i][j];
7062 }
7b208ef4 7063 delete [] endcapassemblyrot[i];
9b0c60ab 7064 delete endcapassemblymatrix[i][0];
7065 delete endcapassemblymatrix[i][1];
7066 }
7067 /////////////////////////////////////////////////////////////
7068 }
7069 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7070 /////////////////////////////////////////////////////////////
7071 // Setting End Cap Support + End Cap Assembly of Layer 5.
7072 /////////////////////////////////////////////////////////////
7073 if (! moth) {
160835d5 7074 AliError("Can't insert end cap support of layer5, mother is null!\n");
9b0c60ab 7075 return;
7076 };
e5bf64ae 7077 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7078 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7079 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7080 fgkEndCapSupportCenterLay5ITSPosition
7081 + fgkEndCapSupportCenterLay5Position
7082 - fgkEndCapSideCoverLength[2]);
7083 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7084 fgkEndCapSideCoverLength[2]
7085 - fgkEndCapSupportCenterLay5Position
7086 - fgkEndCapSupportCenterLay5ITSPosition);
7087 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7088 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7089 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7090 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7091 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7092 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7093 /////////////////////////////////////////////////////////////
7094 // Deallocating memory
7095 /////////////////////////////////////////////////////////////
7096 delete endcapsupportsystemrot;
7097 delete endcapsupportsystemITSCentertrans[1];
7098 }
7099 /////////////////////////////////////////////////////////////
7100 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7101 /////////////////////////////////////////////////////////////
7102 // Setting End Cap Support + End Cap Assembly of Layer 6.
7103 /////////////////////////////////////////////////////////////
7104 if (! moth) {
160835d5 7105 AliError("Can't insert end cap support of layer6, mother is null!\n");
9b0c60ab 7106 return;
7107 };
e5bf64ae 7108 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7109 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7110 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7111 fgkEndCapSupportCenterLay6ITSPosition
7112 + fgkEndCapSupportCenterLay6Position
7113 - fgkEndCapSideCoverLength[2]);
7114 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7115 fgkEndCapSideCoverLength[2]
7116 - fgkEndCapSupportCenterLay6Position
7117 - fgkEndCapSupportCenterLay6ITSPosition);
7118 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7119 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7120 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7121 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7122 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7123 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7124 /////////////////////////////////////////////////////////////
7125 // Deallocating memory
7126 /////////////////////////////////////////////////////////////
7127 delete endcapsupportsystemrot;
7128 delete endcapsupportsystemITSCentertrans[1];
7129 }
7130 ////////////////////////////////////////////////////////////////////////////////
7131 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7132 /////////////////////////////////////////////////////////////
7133 // Setting Ladder Support of Layer 5.
7134 /////////////////////////////////////////////////////////////
7135 if (! moth) {
160835d5 7136 AliError("Can't insert ladder lupport of layer5, mother is null!\n");
9b0c60ab 7137 return;
7138 };
7139 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7140 fMotherVol = moth;
7141 TGeoTranslation* centerITSRingSupportLay5trans[2];
7142 for(Int_t i=0; i<2; i++){
7143 centerITSRingSupportLay5trans[i] =
7144 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7145 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7146 }
7147 }
7148 ////////////////////////////////////////////////////////////////////////////////
7149 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7150 /////////////////////////////////////////////////////////////
7151 // Setting Ladder Support of Layer 6.
7152 /////////////////////////////////////////////////////////////
7153 if (! moth) {
160835d5 7154 AliError("Can't insert ladder lupport of layer6, mother is null!\n");
9b0c60ab 7155 return;
7156 };
7157 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7158 fMotherVol = moth;
7159 TGeoTranslation* centerITSRingSupportLay6trans[2];
7160 for(Int_t i=0; i<2; i++){
7161 centerITSRingSupportLay6trans[i] =
7162 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7163 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7164 }
7165 }
7166 ////////////////////////////////////////////////////////////////////////////////
47f8de53 7167 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7168 /////////////////////////////////////////////////////////////
7169 // Setting Ladder Support of Layer 6.
7170 /////////////////////////////////////////////////////////////
7171 if (! moth) {
160835d5 7172 AliError("Can't insert SSD Cone, mother is null!\n");
47f8de53 7173 return;
7174 };
7175 if(!fSSDCone) SetSSDCone();
7176 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7177 + fgkSSDCentralAL3SupportLength);
7178 moth->AddNode(fSSDCone,1,ssdconetrans);
7179}
7180 ////////////////////////////////////////////////////////////////////////////////
7181 void AliITSv11GeometrySSD::SetSSDCone(){
7182 /////////////////////////////////////////////////////////////
7183 // Method generating SSDCone
7184 /////////////////////////////////////////////////////////////
7185 if(!fCreateMaterials) CreateMaterials();
7186 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7187 Double_t ssdpconesectionradiusmax[16];
7188 Double_t ssdpconesectionradiusmin[16];
7189 Double_t ssdpconezsection[16];
7190 TGeoPcon* ssdpconelittleholeshape[8];
7191 TGeoVolume* ssdpconelittlehole[8];
7192 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7193 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7194 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7195 / SinD(fgkSSDPConeAngle)
7196 + ssdpconesectionradiusmin[0];
7197 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7198 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7199 / SinD(fgkSSDPConeAngle);
7200 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7201 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7202 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7203 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7204 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7205 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7206 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7207 ssdpconelittlehole[0]->SetLineColor(4);
7208 /////////////////////////////////////////////////////////////
7209 ssdpconezsection[2] = ssdpconezsection[1];
7210 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7211 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7212 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7213 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7214 / SinD(fgkSSDPConeAngle);
7215 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7216 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7217 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7218 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7219 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7220 * TMath::RadToDeg();
7221 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7222 60.-ssdpconelittleholeangle,2);
7223 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7224 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7225 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7226 ssdpconelittlehole[1]->SetLineColor(4);
7227 TGeoRotation* ssdconelittleholerot[6];
7228 for(Int_t i=0; i<6; i++){
7229 ssdconelittleholerot[i] = new TGeoRotation();
7230 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7231 }
7232 /////////////////////////////////////////////////////////////
7233 ssdpconezsection[4] = ssdpconezsection[3];
7234 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7235 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7236 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7237 * CosD(fgkSSDPConeAngle)
7238 / SinD(fgkSSDPConeAngle);
7239 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7240 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7241 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7242 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7243 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7244 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7245 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7246 ssdpconelittlehole[2]->SetLineColor(4);
7247 ///////////////////////////////////////////////////
7248 ssdpconezsection[6] = ssdpconezsection[5];
7249 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7250 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7251 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7252 -ssdpconezsection[0]
7253 * CosD(fgkSSDPConeAngle)
7254 / SinD(fgkSSDPConeAngle);
7255 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7256 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7257 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7258 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7259 * TMath::RadToDeg();
7260 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7261 45.-ssdpconemiddleholeangle,2);
7262 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7263 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7264 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7265 ssdpconelittlehole[3]->SetLineColor(4);
7266 TGeoRotation* ssdconemiddleholerot[8];
7267 for(Int_t i=0; i<8; i++){
7268 ssdconemiddleholerot[i] = new TGeoRotation();
7269 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7270 }
7271 /////////////////////////////////////////////////////////////
7272 ssdpconezsection[8] = ssdpconezsection[7];
7273 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7274 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7275 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7276 * CosD(fgkSSDPConeAngle)
7277 / SinD(fgkSSDPConeAngle);
7278 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7279 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7280 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7281 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7282 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7283 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7284 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7285 ssdpconelittlehole[4]->SetLineColor(4);
7286 /////////////////////////////////////////////////////////////
7287 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7288 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7289 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7290 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7291 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7292 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7293 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7294 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7295 * TMath::RadToDeg();
7296 ssdpconezsection[10] = ssdpconezsection[9];
7297 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7298 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7299 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7300 * CosD(fgkSSDPConeAngle)
7301 / SinD(fgkSSDPConeAngle);
7302 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7303 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7304 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7305 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7306 ssdpconetrapezoidsectionangle,2);
7307 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7308 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7309 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7310 ssdpconelittlehole[5]->SetLineColor(4);
7311 TGeoRotation* ssdconeupradiusrot[8];
7312 for(Int_t i=0; i<8; i++){
7313 ssdconeupradiusrot[i] = new TGeoRotation();
7314 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7315 }
7316 /////////////////////////////////////////////////////////////
7317 ssdpconezsection[12] = ssdpconezsection[11];
7318 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7319 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7320 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7321 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7322 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7323 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7324 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7325 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7326 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7327 ssdpconelittlehole[6]->SetLineColor(4);
7328 /////////////////////////////////////////////////////////////
7329 ssdpconezsection[14] = 0.0;
7330 ssdpconezsection[15] = ssdpconezsection[0];
7331 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7332 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7333 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7334 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7335 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7336 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7337 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7338 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7339 ssdpconelittlehole[7]->SetLineColor(4);
7340 /////////////////////////////////////////////////////////////
7341 TGeoTube* ssdtubeconeshape[2];
7342 TGeoVolume* ssdtubecone[2];
7343 TGeoTranslation* ssdtubeconetrans[2];
7344 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7345 fgkSSDPConeExternalRadius,
7346 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7347 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7348 0.5*ssdpconezsection[0]);
7349 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7350 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7351 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7352 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7353 + ssdpconezsection[13]);
7354 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7355 ssdtubecone[0]->SetLineColor(4);
7356 ssdtubecone[1]->SetLineColor(4);
7357 /////////////////////////////////////////////////////////////
7358 // Mother Volume Container
7359 /////////////////////////////////////////////////////////////
7360 Double_t ssdconemotherradiusmin[8];
7361 Double_t ssdconemotherradiusmax[8];
7362 Double_t ssdconemothersection[8];
7363 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7364 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7365 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7366 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7367 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7368 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7369 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7370 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7371 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7372 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7373 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7374 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7375 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7376 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7377 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7378 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7379 ssdconemothersection[0] = 0.0;
7380 ssdconemothersection[1] = ssdpconezsection[0];
7381 ssdconemothersection[2] = ssdpconezsection[0];
7382 ssdconemothersection[3] = ssdpconezsection[11];
7383 ssdconemothersection[4] = ssdpconezsection[11];
7384 ssdconemothersection[5] = ssdpconezsection[13];
7385 ssdconemothersection[6] = ssdpconezsection[13];
7386 ssdconemothersection[7] = fgkSSDPConeLength;
7387 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7388 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7389 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7390 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7391 /////////////////////////////////////////////////////////////
7392 //Placing the Volumes into Mother
7393 /////////////////////////////////////////////////////////////
7394 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7395 for(Int_t i=0; i<6; i++){
7396 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7397 }
7398 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7399 for(Int_t i=0; i<8; i++){
7400 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7401 }
7402 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7403 for(Int_t i=0; i<8; i++){
7404 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7405 }
7406 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7407 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7408 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7409 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7410 /////////////////////////////////////////////////////////////
7411 // ITS General Support
7412 /////////////////////////////////////////////////////////////
7413 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7414 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7415 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7416 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7417 - fgkSSDCentralAL3SupportLength);
7418 ssdcentralsupport->SetLineColor(4);
7419 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7420 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7421 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7422 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7423 TGeoTranslation* ssdcentralal3supportrans[3];
7424 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7425 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7426 - 1.25*fgkSSDCentralAL3SupportLength);
7427 ssdcentralal3support->SetLineColor(4);
7428 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7429 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7430 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7431 Double_t ssdpconcentralradiusmin[2];
7432 Double_t ssdpconcentralradiusmax[2];
7433 Double_t ssdpconcentralsection[2];
7434 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7435 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7436 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7437 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7438 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7439 ssdpconcentralsection[1] = 0.;
7440 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7441 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7442 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7443 ssdpconcentralal3->SetLineColor(4);
7444 fSSDCone->AddNode(ssdpconcentralal3,1);
7445 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7446 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7447 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7448 -2.*fgkSSDCentralAL3SupportLength);
7449 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7450 *ssdcentralal3supportrot);
7451 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7452 TGeoRotation* ssdconemotherot = new TGeoRotation();
7453 ssdconemotherot->SetAngles(90.,180.,-90.);
7454 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7455 -2.*fgkSSDCentralAL3SupportLength);
7456 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7457 fSSDCone->AddNode(ssdconemother,1);
7458 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7459 /////////////////////////////////////////////////////////////
7460 // Deallocating memory
7461 /////////////////////////////////////////////////////////////
7462 delete ssdcentralal3supportrot;
7463 delete ssdcentralal3supportrans[2];
7464 delete ssdconemotherot;
7465 delete ssdconemothertrans;
7466 /////////////////////////////////////////////////////////////
7467 }
fcfbdd23 7468 ////////////////////////////////////////////////////////////////////////////////
7469 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7470 /////////////////////////////////////////////////////////////
7471 // Setting SSD Cables
7472 /////////////////////////////////////////////////////////////
7473 if (! moth) {
160835d5 7474 AliError("Can't insert SSD Cables, mother is null!\n");
fcfbdd23 7475 return;
7476 };
7477 TGeoVolume* ssdcables = SetSSDCables();
7478 moth->AddNode(ssdcables,1);
7479}
47f8de53 7480 ////////////////////////////////////////////////////////////////////////////////
7481 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7482 /////////////////////////////////////////////////////////////
7483 // Method generating SSDCables
7484 /////////////////////////////////////////////////////////////
7485 // SSD Layer 5 Cables
7486 //////////////////////////////////////////////////////////////////////////////////////////////////
7487 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7488 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
fcfbdd23 7489 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
47f8de53 7490 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7491 //////////////////////////////////////////////////////////////////////////////////////////////////
7492 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+fgkSSDCablesLay5TubeRadiusMin;
7493 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7494 - fgkSSDLowerPConeRadius)
7495 * TanD(fgkSSDPConeAngle);
7496 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7497 + fgkEndCapSupportCenterLay5Position
7498 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7499 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7500 - ssdcableslay5startconedistance;
7501 ssdcablelay5rightsidelength *= ssdcablesfactor;
7502 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+fgkSSDCablesLay5RightSideHeight;
7503 TGeoTube* ssdcablelay5rightubeshape = new TGeoTube(ssdcableslay5rigthsideradiusmin,
7504 ssdcableslay5rightsideradiusmax,
7505 0.5*ssdcablelay5rightsidelength);
7506 TGeoVolume* ssdcablelay5righttube = new TGeoVolume("SSDCableLay5RightSideTube",
7507 ssdcablelay5rightubeshape,
7508 fSSDCopper);
7509 ssdcablelay5righttube->SetLineColor(9);
7510 TGeoTranslation* ssdcablelay5rightrans =
7511 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7512 + fgkEndCapSupportCenterLay5Position
7513 + 0.5*ssdcablelay5rightsidelength);
7514 ////////////////////////////////////
7515 // Double_t cablescapacity[20];
7516 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7517 ////////////////////////////////////
7518 ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7519 ////////////////////////////////////
7520 // TGeoPCone Volumes
7521 ///////////////////////////////////
7522 TGeoPcon* ssdcableslay5pconshape[3];
7523 TGeoVolume* ssdcableslay5pcon[3];
7524 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7525 Double_t ssdcableslay5pconzsection[6];
7526 Double_t ssdcableslay5pconrmin[6];
7527 Double_t ssdcableslay5pconrmax[6];
7528 ssdcableslay5pconrmin[0] = ssdcablelay5rightubeshape->GetRmin();
7529 ssdcableslay5pconrmax[0] = ssdcablelay5rightubeshape->GetRmax();
7530 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7531 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+fgkSSDCablesLay5RightSideHeight;
7532 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7533 + fgkEndCapSupportCenterLay5Position
7534 + 2.*ssdcablelay5rightubeshape->GetDz();
7535 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7536 + fgkSSDCentralAL3SupportLength
7537 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7538 * TanD(fgkSSDPConeAngle);
7539 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7540 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7541 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7542 ssdcableslay5pconshape[0],fSSDCopper);
7543 ssdcableslay5pcon[0]->SetLineColor(9);
7544 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7545////////////////////////////////////
7546// cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7547////////////////////////////////////
7548 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7549 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7550 + fgkSSDCentralAL3SupportLength
7551 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7552 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7553 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7554 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7555 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7556 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7557 ssdcableangle,2);
7558 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7559 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7560 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7561 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7562 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7563 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3]+fgkSSDCablesLay5RightSideHeight;
7564 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7565 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7566 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7567 ssdcableslay5pcon[1]->SetLineColor(9);
7568 ////////////////////////////////////
7569 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7570 ssdcableangle,2);
7571 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7572 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7573 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7574 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7575 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7576 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7577 * TanD(fgkSSDPConeAngle)
7578 + 0.5*fgkSSDCentralSupportLength
7579 + fgkSSDCentralAL3SupportLength;
7580 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7581 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7582 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7583 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7584 ssdcableslay5pcon[2]->SetLineColor(9);
7585////////////////////////////////////
7586 TGeoRotation* ssdcableslay5pconrot[4];
7587 for(Int_t i=0; i<4; i++){
7588 ssdcableslay5pconrot[i] = new TGeoRotation();
7589 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7590 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7591 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
7592 }
7593 ////////////////////////////////////
7594 //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7595 //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7596 ////////////////////////////////////
7597 // Positioning Left SSD Cables Part
7598 ////////////////////////////////////
7599 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7600 - 0.5*ssdcablelay5rightsidelength
7601 - fgkEndCapSupportCenterLay5Position
7602 - fgkEndCapSupportCenterLay5ITSPosition);
7603 ssdcablesmother->AddNode(ssdcablelay5righttube,2,ssdcablesLay5RightTubeToLeftrans);
7604 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7605 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7606 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7607 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7608 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7609 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7610 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7611 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7612 }
7613 ////////////////////////////////////
7614 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7615 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7616 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7617 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7618 /////////////////////////////////////////////////////////////
7619 // Water Tubes Layer 5
7620 /////////////////////////
7621 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7622 ssdcableslay5rightsideradiusmax
7623 + fgkSSDCablesLay5RightSideWaterHeight,
7624 0.5*ssdcablelay5rightsidelength);
7625 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7626 ssdcablelay5rightubewatershape,
7627 fSSDCoolingTubeWater);
7628 ssdcablelay5rightwatertube->SetLineColor(7);
7629 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7630 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7631 ////////////////////////////////////
7632 // TGeoPCone Water Volumes Layer
7633 ///////////////////////////////////
7634 TGeoPcon* ssdcableslay5pconwatershape[3];
7635 TGeoVolume* ssdcableslay5pconwater[3];
7636 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7637 Double_t ssdcableslay5pconwaterzsection[6];
7638 Double_t ssdcableslay5pcwateronrmin[6];
7639 Double_t ssdcableslay5pconwaterrmax[6];
7640 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7641 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7642 + fgkSSDCablesLay5RightSideWaterHeight;
7643 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7644 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7645 + fgkSSDCablesLay5RightSideWaterHeight;
7646 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7647 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7648 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7649 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7650 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7651 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7652 ssdcableslay5pconwater[0]->SetLineColor(7);
7653 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7654 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7655////////////////////////////////////
7656 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7657 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7658 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7659 ssdcableangle,2);
7660 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7661 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7662 + fgkSSDCablesLay5RightSideWaterHeight;
7663 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7664 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7665 + fgkSSDCablesLay5RightSideWaterHeight;
7666 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7667 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7668 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7669 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7670 ssdcableslay5pconwater[1]->SetLineColor(7);
7671////////////////////////////////////
7672 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7673 ssdcableangle,2);
7674 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7675 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7676 + fgkSSDCablesLay5RightSideWaterHeight;
7677 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7678 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7679 + fgkSSDCablesLay5RightSideWaterHeight;
7680 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7681 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7682 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7683 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7684 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7685 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7686 ssdcableslay5pconwater[2]->SetLineColor(7);
7687////////////////////////////////////
7688 TGeoRotation* ssdcableslay5pconwaterot[4];
7689 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7690 for(Int_t i=0; i<4; i++){
7691 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7692 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7693 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7694 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7695 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7696 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7697 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7698 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7699 }
7700 /////////////////////////
7701 // SSD Layer 6 Cables
7702 /////////////////////////
7703 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+fgkSSDCablesLay6TubeRadiusMin;
7704 Double_t ssdcablelay6rightsidelength = 2.*ssdcablelay5rightsidelength;
7705 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+fgkSSDCablesLay6RightSideHeight;
7706 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7707 ssdcableslay6rightsideradiusmax,
7708 0.5*ssdcablelay6rightsidelength);
7709 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7710 ssdcablelay6rightubeshape,
7711 fSSDCopper);
7712 ssdcablelay6righttube->SetLineColor(9);
7713 TGeoTranslation* ssdcablelay6rightrans =
7714 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7715 + fgkEndCapSupportCenterLay6Position
7716 + 0.5*ssdcablelay6rightsidelength);
7717 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7718 - 0.5*ssdcablelay6rightsidelength
7719 - fgkEndCapSupportCenterLay6Position
7720 - fgkEndCapSupportCenterLay6ITSPosition);
7721 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7722 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7723 ////////////////////////////////////
7724 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7725 ////////////////////////////////////
7726 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7727 ssdcableangle,2);
7728 TGeoVolume* ssdcableslay6pcon;
7729 Double_t ssdcableslay6pconrmin[2];
7730 Double_t ssdcableslay6pconrmax[2];
7731 Double_t ssdcableslay6pconzsection[2];
7732 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7733 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7734 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7735 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7736 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7737 + fgkEndCapSupportCenterLay6Position
7738 + ssdcablelay6rightsidelength;
7739 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7740 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7741 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7742 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7743 ssdcableslay6pconshape,fSSDCopper);
7744 ssdcableslay6pcon->SetLineColor(9);
7745 for(Int_t i=0; i<4; i++){
7746 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7747 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7748 }
7749 ////////////////////////////////////
7750 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7751 /////////////////////////
7752 // Water Tubes Layer 6
7753 /////////////////////////
7754 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7755 ssdcableslay6rightsideradiusmax
7756 + fgkSSDCablesLay5RightSideWaterHeight,
7757 0.5*ssdcablelay6rightsidelength);
7758 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7759 ssdcablelay6righwatertubeshape,
7760 fSSDCoolingTubeWater);
7761 ssdcablelay6rightwatertube->SetLineColor(7);
7762 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7763 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7764 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7765 ssdcableangle,2);
7766 TGeoVolume* ssdcableslay6waterpcon;
7767 Double_t ssdcableslay6waterpconrmin[2];
7768 Double_t ssdcableslay6waterpconrmax[2];
7769 Double_t ssdcableslay6waterpconzsection[2];
7770 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7771 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7772 + fgkSSDCablesLay5RightSideWaterHeight;
7773 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7774 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7775 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7776 + fgkEndCapSupportCenterLay6Position
7777 + ssdcablelay6rightsidelength;
7778 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7779 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7780 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7781 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7782 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7783 ssdcableslay6waterpcon->SetLineColor(7);
7784 TGeoRotation* ssdcableslay6pconwaterot[4];
7785 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7786 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7787 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7788 for(Int_t i=0; i<4; i++){
7789 ssdcableslay6pconwaterot[i] = new TGeoRotation();
7790 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7791 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7792 * (*ssdcableslay6pconwaterot[i]));
7793 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7794 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7795 }
7796 ////////////////////////////////////////
7797 // From ITS Ring to Patch Panel3-RB26
7798 ////////////////////////////////////////
7799 Double_t ssdcablepatchpanel3BB26radiusmin[2];
7800 Double_t ssdcablepatchpanel3BB26radiusmax[2];
7801 Double_t ssdcablepatchpanel3RB26zsection[2];
cd2243fb 7802 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8;
47f8de53 7803 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
7804 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7805 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7806 ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
7807 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
7808 + 0.*fgkSSDCablesLay5RightSideHeight
cd2243fb 7809 + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7810 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
7811 + fgkSSDCentralAL3SupportLength
7812 + fgkSSDPConeZLength[0];
7813 ssdcablepatchpanel3RB26zsection[1] = fgkSSDPatchPanel2RB26ITSDistance;
7814 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
7815 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7816 - 0.5*ssdcableangle,ssdcableangle,2);
7817 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7818 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7819 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7820 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7821 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
85f741d8 7822 TGeoRotation* ssdcablepatchpanel3B26rot[4];
47f8de53 7823 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
67446e8a 7824 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
47f8de53 7825 ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
67446e8a 7826 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7827 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
47f8de53 7828 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0]
67446e8a 7829 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
47f8de53 7830 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
7831 ////////////////////////////////////
7832 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7833 ////////////////////////////////////////
7834 // ITS Ring Cables RB26 Part
7835 ////////////////////////////////////////
7836 Double_t ssdcableitsring3BB26pconzsection[2];
7837 Double_t ssdcableitsring3BB26pconrmin[2];
7838 Double_t ssdcableitsring3BB26pconrmax[2];
7839 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7840 + fgkSSDCentralAL3SupportLength
7841 + (4.0/5.0)*fgkSSDPConeZLength[0];
7842 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
cd2243fb 7843 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
47f8de53 7844 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
7845 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7846 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7847 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7848 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7849 TGeoPcon* ssdcableitsring3BB26pconshape[4];
7850 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7851 - 0.5*ssdcableangle,ssdcableangle
7852 + (fgkSSDCablesPatchPanel2RB26Angle[0]
7853 - fgkSSDCableAngle),2);
7854 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7855 - 0.5*ssdcableangle,ssdcableangle
7856 + 3.0*fgkSSDCableAngle
7857 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7858 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-fgkSSDCablesPatchPanel2RB26Angle[0]
7859 - 0.5*ssdcableangle,ssdcableangle
7860 - fgkSSDCableAngle
7861 + fgkSSDCablesPatchPanel2RB26Angle[0],2);
7862 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7863 - 0.5*ssdcableangle,ssdcableangle
7864 + 3.0*fgkSSDCableAngle
7865 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7866 for(Int_t i=0;i<4;i++)
7867 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7868 ssdcableitsring3BB26pconrmin[j],
7869 ssdcableitsring3BB26pconrmax[j]);
7870 TGeoVolume* ssdcableitsring3BB26pcon[4];
7871 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7872 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7873 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7874 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7875 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7876 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7877 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7878 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7879 for(Int_t i=0;i<4;i++){
7880 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
5ef8864c 7881 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
47f8de53 7882}
7883 ////////////////////////////////////
7884 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7885 // + ssdcableitsring3BB26pconshape[1]->Capacity()
7886 // + ssdcableitsring3BB26pconshape[2]->Capacity()
7887 // + ssdcableitsring3BB26pconshape[3]->Capacity();
7888 ////////////////////////////////////////
7889 // From ITS Ring to Patch Panel2-RB24
7890 ////////////////////////////////////////
7891 Double_t ssdcablepatchpanel3BB24radiusmin[2];
7892 Double_t ssdcablepatchpanel3BB24radiusmax[2];
7893 Double_t ssdcablepatchpanel3RB24zsection[2];
7894 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7895 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
7896 ssdcablepatchpanel3BB24radiusmin[1] = fgkSSDPatchPanel2RB24Radius;
7897 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
7898 + 0.*fgkSSDCablesLay5RightSideHeight
7899 + 0.*fgkSSDCablesLay6RightSideHeight
cd2243fb 7900 + 0.5*fgkSSDPatchPanelHeight;
47f8de53 7901 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7902 - fgkSSDCentralAL3SupportLength
7903 - fgkSSDPConeZLength[0];
7904 ssdcablepatchpanel3RB24zsection[1] = -fgkSSDPatchPanel2RB24ITSDistance;
7905 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
7906 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7907 - 0.5*ssdcableangle,ssdcableangle,2);
7908 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7909 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7910 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7911 ssdcablepatchpanel3RB24pconshape,
7912 fSSDCopper);
7913 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
85f741d8 7914 TGeoRotation* ssdcablepatchpanel3B24rot[4];
47f8de53 7915 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
67446e8a 7916 ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
47f8de53 7917 ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0]
7918 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
67446e8a 7919 ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
47f8de53 7920 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0]
7921 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7922 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
7923 ////////////////////////////////////
7924 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7925 ////////////////////////////////////////
7926 // ITS Ring Cables RB24 Part
7927 ////////////////////////////////////////
7928 Double_t ssdcableitsring3BB24pconzsection[2];
7929 Double_t ssdcableitsring3BB24pconrmin[2];
7930 Double_t ssdcableitsring3BB24pconrmax[2];
7931 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7932 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
cd2243fb 7933 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
47f8de53 7934 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
7935 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7936 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7937 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
7938 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
7939 TGeoPcon* ssdcableitsring3BB24pconshape[4];
7940 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7941 + (90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7942 - fgkSSDCableAngle),2);
7943 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+fgkSSDCableAngle-0.5*ssdcableangle,
7944 ssdcableangle-fgkSSDCableAngle
7945 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
7946 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7947 - fgkSSDCableAngle
7948 + 90.0-fgkSSDCablesPatchPanel2RB24Angle[1],2);
5ef8864c 7949 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+fgkSSDCableAngle-0.5*ssdcableangle,
47f8de53 7950 ssdcableangle-fgkSSDCableAngle
7951 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
7952 for(Int_t i=0;i<4;i++)
7953 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
7954 ssdcableitsring3BB24pconrmin[j],
7955 ssdcableitsring3BB24pconrmax[j]);
7956 TGeoVolume* ssdcableitsring3BB24pcon[4];
7957 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
7958 ssdcableitsring3BB24pconshape[0],fSSDCopper);
7959 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
7960 ssdcableitsring3BB24pconshape[1],fSSDCopper);
7961 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
7962 ssdcableitsring3BB24pconshape[2],fSSDCopper);
7963 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
7964 ssdcableitsring3BB24pconshape[3],fSSDCopper);
7965 for(Int_t i=0;i<4;i++){
7966 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
5ef8864c 7967 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
47f8de53 7968}
7969 ////////////////////////////////////
7970 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
7971 // + ssdcableitsring3BB24pconshape[1]->Capacity()
7972 // + ssdcableitsring3BB24pconshape[2]->Capacity()
7973 // + ssdcableitsring3BB24pconshape[3]->Capacity();
7974 ////////////////////////////////////
7975 // Volumes for Material Budget
7976 ////////////////////////////////////
7977 TGeoTube* ssdcablelay6materialbudgetubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax
7978 + fgkSSDCablesLay5RightSideWaterHeight,
7979 ssdcableslay6rightsideradiusmax
7980 + fgkSSDCablesLay5RightSideWaterHeight
7981 + fgkSSDCableMaterialBudgetHeight,0.5*ssdcablelay6rightsidelength);
7982 TGeoVolume* ssdcablelay6materialbudgetube = new TGeoVolume("SSDCableLay6MaterialBudgetTube",
7983 ssdcablelay6materialbudgetubeshape,
7984 fSSDCopper);
7985 ssdcablelay6materialbudgetube->SetLineColor(9);
7986 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,1,ssdcablelay6rightrans);
7987 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,2,ssdcablesLay6RightTubeToLeftrans);
7988
7989 TGeoPcon* ssdcablelay6materialbudgetpconshape =
7990 new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
7991 TGeoVolume* ssdcablelay6materialbudgetpcon;
7992 Double_t ssdcablelay6materialbudgetpconrmin[2];
7993 Double_t ssdcablelay6materialbudgetpconrmax[2];
7994 Double_t ssdcablelay6materialbudgetpconzsection[2];
7995 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
7996 + fgkSSDCablesLay5RightSideWaterHeight;
7997 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
7998 + fgkSSDCableMaterialBudgetHeight;
7999 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
8000 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
8001 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
8002 + fgkEndCapSupportCenterLay6Position
8003 + ssdcablelay6rightsidelength;
8004 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
8005 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
8006 ssdcablelay6materialbudgetpconzsection[i],
8007 ssdcablelay6materialbudgetpconrmin[i],
8008 ssdcablelay6materialbudgetpconrmax[i]);
8009 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
8010 ssdcablelay6materialbudgetpconshape,fSSDCopper);
8011 ssdcablelay6materialbudgetpcon->SetLineColor(9);
8012 for(Int_t i=0; i<4; i++){
8013 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
8014 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
8015 }
8016////////////////////////////////////
8017 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
8018 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
8019 Double_t ssdcablesvolume = 0.0;
8020 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
8021 std::cout << ssdcablesvolume << std::endl;*/
8022 return ssdcablesmother;
8023 }
8024 ////////////////////////////////////////////////////////////////////////////////
277f0a14 8025TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3 const * const vertexpos[4] , const Double_t* width,
b671cde1 8026 Double_t height, const char* shapename, Int_t isign) const{
44285dfa 8027 /////////////////////////////////////////////////////////////
8028 // Method generating an Arb shape
8029 /////////////////////////////////////////////////////////////
8030 const Int_t kvertexnumber = 8;
8031 const Int_t ktransvectnumber = 2;
b671cde1 8032 TVector3 vertex[kvertexnumber];
8033 TVector3 transvector[2];
8034 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
44285dfa 8035 /////////////////////////////////////////////////////////////
d7599219 8036 //Setting the vertices for TGeoArb8
44285dfa 8037 /////////////////////////////////////////////////////////////
b671cde1 8038 vertex[0] = *vertexpos[0];
8039 vertex[1] = *vertexpos[1];
8040 vertex[2] = vertex[1];
8041 vertex[3] = vertex[0];
8042 vertex[4] = *vertexpos[2];
8043 vertex[5] = *vertexpos[3];
8044 vertex[6] = vertex[5];
8045 vertex[7] = vertex[4];
8046
8047 // NB: order of points is clockwise
8048 if (isign < 0) {
8049 vertex[2] -= transvector[0];
8050 vertex[3] -= transvector[0];
8051 vertex[6] -= transvector[1];
8052 vertex[7] -= transvector[1];
8053 }
8054 else {
8055 vertex[0] += transvector[0];
8056 vertex[1] += transvector[0];
8057 vertex[4] += transvector[1];
8058 vertex[5] += transvector[1];
8059 }
8060
44285dfa 8061 /////////////////////////////////////////////////////////////
8062 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
b671cde1 8063 for(Int_t i = 0; i<kvertexnumber;i++) {
8064 arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
8065 }
8066
44285dfa 8067 return arbshape;
d7599219 8068}
bf210566 8069///////////////////////////////////////////////////////////////////////////////
8070TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8071 Double_t rmax, Int_t nedges, Double_t height){
8072 /////////////////////////////////////////////////////////////
8073 // Method generating Arc shape
8074 /////////////////////////////////////////////////////////////
8075 const Int_t kvertexnumber = 2*nedges+2;
8076 TGeoXtru* arcshape = new TGeoXtru(2);
8077 TVector3** vertexposition[2];
8078 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8079 Double_t angle = 0.;
8080 for(Int_t i=0; i<nedges+1; i++){
8081 angle = 90.+0.5*phi-i*(phi/nedges);
8082 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
8083 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
8084 }
8085 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8086 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8087 for(Int_t i=0; i<kvertexnumber; i++){
8088 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8089 yvertexpoints[i] = vertexposition[0][i]->Y();
8090 }
8091 else if(i>=1&&i<nedges+2)
8092 {
8093 xvertexpoints[i] = vertexposition[1][i-1]->X();
8094 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8095 }
8096 else
8097 {
8098 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8099 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8100 }
8101 }
8102 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8103 arcshape->DefineSection(0,-0.5*height);
8104 arcshape->DefineSection(1,0.5*height);
44285dfa 8105 /////////////////////////////////////////////////////////////
bf210566 8106 // Deallocating memory
44285dfa 8107 /////////////////////////////////////////////////////////////
bf210566 8108 for(Int_t i=0; i<2; i++){
8109 for(Int_t j=0; j<nedges+1; j++)
8110 delete vertexposition[i][j];
8111 delete [] vertexposition[i];
8112 }
8113 delete [] xvertexpoints;
8114 delete [] yvertexpoints;
8115 /////////////////////////////////////////////////////////////
8116 return arcshape;
d7599219 8117}
8118////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8119TGeoShape* AliITSv11GeometrySSD::GetScrewShape(const Double_t* radius,const Int_t* edgesnumber,const Double_t* section) const {
9b0c60ab 8120 ///////////////////////////////////////////////////////////////////////
8121 // Method Generating the Screw Shape
8122 // radius[0]: outer radius
8123 // radius[1]: inner radius
8124 // edgesnumber[0]: outer number of edges
8125 // edgesnumber[1]: inner number of edges
8126 // section[0]: lower section position
8127 // section[1]: higher section position
8128 ///////////////////////////////////////////////////////////////////////
8129 Double_t outradius = radius[0];
8130 Double_t inradius = radius[1];
8131 Int_t outvertexnumber = edgesnumber[0];
8132 Int_t invertexnumber = edgesnumber[1];
851c0ce3 8133 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8134 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8135 for(Int_t i=0; i<outvertexnumber; i++){
9b0c60ab 8136 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8137 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8138 }
851c0ce3 8139 for(Int_t i=0; i<invertexnumber; i++){
8140 xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8141 yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
9b0c60ab 8142 }
851c0ce3 8143 TGeoXtru* screwshapeout = new TGeoXtru(2);
8144 screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8145 screwshapeout->DefineSection(0,section[0]);
8146 screwshapeout->DefineSection(1,section[1]);
8147 TGeoXtru* screwshapein = new TGeoXtru(2);
8148 screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8149 screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8150 screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8151 TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8152 TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8153
9b0c60ab 8154 delete [] xscrewvertex;
8155 delete [] yscrewvertex;
8156 return screwshape;
8157}
8158////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8159TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, const Double_t *section) const {
9b0c60ab 8160 ///////////////////////////////////////////////////////////////////////
8161 // Method Generating the Hole Shape
8162 // radius of the Hole
8163 // nedges: number of edges to approximate the circle
8164 ///////////////////////////////////////////////////////////////////////
851c0ce3 8165 Double_t* xholevertex = new Double_t[nedges];
8166 Double_t* yholevertex = new Double_t[nedges];
8167 Double_t z = 0.5*(section[0]+section[1]);
8168 Double_t dz = 0.5*(section[1]-section[0]);
8169 TGeoTranslation *tr = 0;
8170 if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8171 tr = new TGeoTranslation(0.,0.,z);
8172 tr->RegisterYourself();
8173 }
8174 TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8175 for(Int_t i=0; i<nedges; i++){
8176 xholevertex[i] = radius*CosD(i*360./nedges);
8177 yholevertex[i] = radius*SinD(i*360./nedges);
9b0c60ab 8178 }
851c0ce3 8179 TGeoXtru* holeshapeout = new TGeoXtru(2);
8180 holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8181 holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8182 holeshapeout->DefineSection(1,section[1]+0.01);
8183 TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8184 TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8185
9b0c60ab 8186 delete [] xholevertex;
8187 delete [] yholevertex;
8188 return holeshape;
8189}
8190////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8191TVector3* AliITSv11GeometrySSD::GetReflection(const TVector3* vector,const Double_t* param) const{
44285dfa 8192 /////////////////////////////////////////////////////////////
8193 // Given an axis specified by param, it gives the reflection of the point
8194 // respect to the axis
8195 /////////////////////////////////////////////////////////////
8196 TVector3* n = new TVector3(param[0],param[1],param[2]);
8197 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8198 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 8199 /////////////////////////////////////////////////////////////
8200 // Deallocating memory
8201 /////////////////////////////////////////////////////////////
8202 delete n;
8203 /////////////////////////////////////////////////////////////
44285dfa 8204 return reflectedvector;
d7599219 8205}
8206////////////////////////////////////////////////////////////////////////////////
bf210566 8207TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
d7599219 8208 Double_t dx,
8209 Double_t dy,
8210 Double_t dz) const{
44285dfa 8211 /////////////////////////////////////////////////////////////
d7599219 8212 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 8213 /////////////////////////////////////////////////////////////
bf210566 8214 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8215 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 8216 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 8217 hmatrix->SetTranslation(newvect);
8218 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8219 delete hmatrix;
8220 return matrix;
d7599219 8221}
8222////////////////////////////////////////////////////////////////////////////////
d7599219 8223TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 8224 /////////////////////////////////////////////////////////////
8225 // Method returning the Medium type
8226 /////////////////////////////////////////////////////////////
a3f8715e 8227 char ch[100];
045be90c 8228 snprintf(ch,100, "ITS_%s",mediumName);
d7599219 8229 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8230 if (! medium)
160835d5 8231 AliError(Form("medium %s not found !\n", mediumName));
d7599219 8232 return medium;
8233}
8234////////////////////////////////////////////////////////////////////////////////
d7599219 8235void AliITSv11GeometrySSD::CreateMaterials(){
8236///////////////////////////////////
8237// This part has to be modified
8238///////////////////////////////////
8239 ///////////////////////////////////
8240 // Silicon for Sensor
8241 ///////////////////////////////////
bf210566 8242 fSSDSensorMedium = GetMedium("SI$");
d7599219 8243 ///////////////////////////////////
8244 // Silicon Mixture for Sensor
8245 ///////////////////////////////////
44285dfa 8246 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8247 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 8248 ///////////////////////////////////
8249 // Stiffener Components Materials
8250 ///////////////////////////////////
bf210566 8251 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 8252 ///////////////////////////
8253 // Stiffener Connectors
8254 ///////////////////////////
bf210566 8255 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 8256 ////////////////////////////////
8257 // Stiffener 0603-1812 Capacitor
8258 ////////////////////////////////
bf210566 8259 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8260 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
78e34526 8261 fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$");
d7599219 8262 ///////////////////////////
8263 // Stiffener Hybrid Wire
8264 ///////////////////////////
bf210566 8265 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 8266 ///////////////////////////
8267 // Al for Cooling Block
8268 ///////////////////////////
bf210566 8269 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 8270 //////////////////////////////////////////////////////
8271 // Kapton and Al for Chip Cable Flex and Ladder Cables
8272 //////////////////////////////////////////////////////
bf210566 8273 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8274 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8275 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8276 fSSDAlTraceFlexMedium = GetMedium("AL$");
8277 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8278 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 8279 /////////////////////////////////////////////////////////////////
8280 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8281 //////////////////////////////////////////////////////////////////
44285dfa 8282 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 8283 /////////////////////////////////////////////////////////////////
8284 // G10 for Detector Leg, TubeHolder
8285 //////////////////////////////////////////////////////////////////
44285dfa 8286 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8287 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8288 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8289 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 8290 /////////////////////////////////////////////////////////////////
8291 // Water and Phynox for Cooling Tube
8292 //////////////////////////////////////////////////////////////////
bf210566 8293 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 8294 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 8295 /////////////////////////////////////////////////////////////////////
9b0c60ab 8296 // Material for Support Rings
8297 /////////////////////////////////////////////////////////////////////
8298 fSSDSupportRingAl = GetMedium("AL$");
47f8de53 8299 fSSDRohaCellCone = GetMedium("ROHACELL$");
9b0c60ab 8300 /////////////////////////////////////////////////////////////////////
bf210566 8301 fSSDAir = GetMedium("SDD AIR$");
47f8de53 8302 fSSDCopper = GetMedium("COPPER$");
78e34526 8303 fSSDSn = GetMedium("Sn$");
bf210566 8304 fCreateMaterials = kTRUE;
d7599219 8305}
8306/////////////////////////////////////////////////////////////////////
277f0a14 8307